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;
}
}
}
- else if (intrinsic == NI_AdvSimd_Insert)
+ else if ((intrinsic == NI_AdvSimd_Insert) || (intrinsic == NI_AdvSimd_InsertScalar))
{
op2 = addRangeCheckIfNeeded(intrinsic, op2, mustExpand, immLowerBound, immUpperBound);
}
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:
}
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);
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)
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)
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)
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:
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();
<Compile Include="Insert.Vector128.UInt16.1.cs" />
<Compile Include="Insert.Vector128.UInt32.1.cs" />
<Compile Include="Insert.Vector128.UInt64.1.cs" />
+ <Compile Include="InsertScalar.Vector128.Double.1.cs" />
+ <Compile Include="InsertScalar.Vector128.Int64.1.cs" />
+ <Compile Include="InsertScalar.Vector128.UInt64.1.cs" />
<Compile Include="LeadingSignCount.Vector64.Int16.cs" />
<Compile Include="LeadingSignCount.Vector64.Int32.cs" />
<Compile Include="LeadingSignCount.Vector64.SByte.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt16.Vector128.UInt16.7.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt32.Vector64.UInt32.1.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt32.Vector128.UInt32.3.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="Program.AdvSimd_Part2.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Compile Include="Insert.Vector128.UInt16.1.cs" />
<Compile Include="Insert.Vector128.UInt32.1.cs" />
<Compile Include="Insert.Vector128.UInt64.1.cs" />
+ <Compile Include="InsertScalar.Vector128.Double.1.cs" />
+ <Compile Include="InsertScalar.Vector128.Int64.1.cs" />
+ <Compile Include="InsertScalar.Vector128.UInt64.1.cs" />
<Compile Include="LeadingSignCount.Vector64.Int16.cs" />
<Compile Include="LeadingSignCount.Vector64.Int32.cs" />
<Compile Include="LeadingSignCount.Vector64.SByte.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt16.Vector128.UInt16.7.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt32.Vector64.UInt32.1.cs" />
<Compile Include="MultiplyBySelectedScalar.Vector128.UInt32.Vector128.UInt32.3.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7.cs" />
- <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="Program.AdvSimd_Part2.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Optimize />
</PropertyGroup>
<ItemGroup>
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3.cs" />
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7.cs" />
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector64.UInt16.3.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector128.UInt16.7.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.Int32.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.Int64.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.SByte.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int16.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int32.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.SByte.cs" />
<Compile Include="Program.AdvSimd_Part3.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3.cs" />
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7.cs" />
+ <Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector128.Int32.3.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector64.UInt16.3.cs" />
<Compile Include="MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector128.UInt16.7.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.Int32.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.Int64.cs" />
<Compile Include="ShiftArithmeticRounded.Vector128.SByte.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int16.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int32.cs" />
- <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.SByte.cs" />
<Compile Include="Program.AdvSimd_Part3.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Optimize />
</PropertyGroup>
<ItemGroup>
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int16.cs" />
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int32.cs" />
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.SByte.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int16.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int32.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int64.cs" />
<Compile Include="ShiftArithmeticSaturate.Vector128.SByte.cs" />
<Compile Include="ShiftArithmeticSaturateScalar.Vector64.Int64.cs" />
<Compile Include="ShiftArithmeticScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Byte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Int16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Int32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.SByte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.UInt16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.UInt32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Byte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.SByte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt64.cs" />
+ <Compile Include="ShiftLeftAndInsertScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Byte.1.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Int16.1.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Int32.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt16.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt32.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt64.1.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Byte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Int16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Int32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.SByte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.UInt16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.UInt32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Byte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.SByte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsertScalar.Vector64.Int64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Byte.1.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Int16.1.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt16.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt32.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt64.cs" />
+ <Compile Include="ShiftRightAndInsertScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftRightAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalAdd.Vector128.UInt64.1.cs" />
<Compile Include="ShiftRightLogicalAddScalar.Vector64.Int64.1.cs" />
<Compile Include="ShiftRightLogicalAddScalar.Vector64.UInt64.1.cs" />
- <Compile Include="ShiftRightLogicalAndInsertScalar.Vector64.Int64.cs" />
- <Compile Include="ShiftRightLogicalAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Byte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt16.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt32.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1.cs" />
<Compile Include="Program.AdvSimd_Part4.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int16.cs" />
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.Int32.cs" />
+ <Compile Include="ShiftArithmeticRoundedSaturate.Vector64.SByte.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int16.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int32.cs" />
<Compile Include="ShiftArithmeticRoundedSaturate.Vector128.Int64.cs" />
<Compile Include="ShiftArithmeticSaturate.Vector128.SByte.cs" />
<Compile Include="ShiftArithmeticSaturateScalar.Vector64.Int64.cs" />
<Compile Include="ShiftArithmeticScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Byte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Int16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.Int32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.SByte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.UInt16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector64.UInt32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Byte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.SByte.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt16.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt32.cs" />
+ <Compile Include="ShiftLeftAndInsert.Vector128.UInt64.cs" />
+ <Compile Include="ShiftLeftAndInsertScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftLeftAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Byte.1.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Int16.1.cs" />
<Compile Include="ShiftLeftLogical.Vector64.Int32.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt16.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt32.1.cs" />
<Compile Include="ShiftLeftLogical.Vector128.UInt64.1.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Byte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Int16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.Int32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.SByte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.UInt16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector64.UInt32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Byte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.Int64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.SByte.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt16.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt32.cs" />
- <Compile Include="ShiftLeftLogicalAndInsert.Vector128.UInt64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsertScalar.Vector64.Int64.cs" />
- <Compile Include="ShiftLeftLogicalAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Byte.1.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Int16.1.cs" />
<Compile Include="ShiftLeftLogicalSaturate.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt16.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt32.cs" />
<Compile Include="ShiftRightAndInsert.Vector128.UInt64.cs" />
+ <Compile Include="ShiftRightAndInsertScalar.Vector64.Int64.cs" />
+ <Compile Include="ShiftRightAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightArithmetic.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalAdd.Vector128.UInt64.1.cs" />
<Compile Include="ShiftRightLogicalAddScalar.Vector64.Int64.1.cs" />
<Compile Include="ShiftRightLogicalAddScalar.Vector64.UInt64.1.cs" />
- <Compile Include="ShiftRightLogicalAndInsertScalar.Vector64.Int64.cs" />
- <Compile Include="ShiftRightLogicalAndInsertScalar.Vector64.UInt64.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Byte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt16.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt32.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1.cs" />
- <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1.cs" />
<Compile Include="Program.AdvSimd_Part4.cs" />
<Compile Include="..\Shared\Helpers.cs" />
<Compile Include="..\Shared\Program.cs" />
<Optimize />
</PropertyGroup>
<ItemGroup>
+ <Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt32.1.cs" />
+ <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1.cs" />
+ <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1.cs" />
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
+ <Compile Include="ShiftRightLogicalNarrowingLower.Vector64.UInt32.1.cs" />
+ <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1.cs" />
+ <Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1.cs" />
<Compile Include="ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1.cs" />
--- /dev/null
+// 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<Double>();
+ int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Double>();
+ int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Double>();
+ 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<byte>(inArray1Ptr), ref Unsafe.As<Double, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Double, 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 Vector128<Double> _fld1;
+ public Vector64<Double> _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<Vector128<Double>, byte>(ref testStruct._fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref testStruct._fld3), ref Unsafe.As<Double, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
+
+ 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<Double>* pFld1 = &_fld1)
+ fixed (Vector64<Double>* 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<Vector128<Double>>() / sizeof(Double);
+ private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Double>>() / sizeof(Double);
+ private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Double>>() / 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<Double> _clsVar1;
+ private static Vector64<Double> _clsVar3;
+
+ private Vector128<Double> _fld1;
+ private Vector64<Double> _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<Vector128<Double>, byte>(ref _clsVar1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _clsVar3), ref Unsafe.As<Double, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
+ }
+
+ 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<Vector128<Double>, byte>(ref _fld1), ref Unsafe.As<Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Double>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Double>, byte>(ref _fld3), ref Unsafe.As<Double, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Double>>());
+
+ 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<Vector128<Double>>(_dataTable.inArray1Ptr),
+ 1,
+ Unsafe.Read<Vector64<Double>>(_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<Double>), typeof(byte), typeof(Vector64<Double>) })
+ .Invoke(null, new object[] {
+ Unsafe.Read<Vector128<Double>>(_dataTable.inArray1Ptr),
+ ElementIndex,
+ Unsafe.Read<Vector64<Double>>(_dataTable.inArray3Ptr)
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Double>)(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<Double>), typeof(byte), typeof(Vector64<Double>) })
+ .Invoke(null, new object[] {
+ AdvSimd.LoadVector128((Double*)(_dataTable.inArray1Ptr)),
+ ElementIndex,
+ AdvSimd.LoadVector64((Double*)(_dataTable.inArray3Ptr))
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Double>)(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<Double>* pClsVar1 = &_clsVar1)
+ fixed (Vector64<Double>* 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<Vector128<Double>>(_dataTable.inArray1Ptr);
+ var op3 = Unsafe.Read<Vector64<Double>>(_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<Double>* pFld1 = &test._fld1)
+ fixed (Vector64<Double>* 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<Double>* pFld1 = &_fld1)
+ fixed (Vector64<Double>* 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<Double> op1, Vector64<Double> 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<Double, byte>(ref inArray1[0]), op1);
+ Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray3[0]), op3);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Double>>());
+
+ 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<Double, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Double>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Double>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Double>>());
+
+ 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)}<Double>(Vector128<Double>, 1, Vector64<Double>): {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;
+ }
+ }
+ }
+}
--- /dev/null
+// 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<Int64>();
+ int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<Int64>();
+ int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<Int64>();
+ 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<byte>(inArray1Ptr), ref Unsafe.As<Int64, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<Int64, 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 Vector128<Int64> _fld1;
+ public Vector64<Int64> _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<Vector128<Int64>, byte>(ref testStruct._fld1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int64>, byte>(ref testStruct._fld3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
+
+ 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<Int64>* pFld1 = &_fld1)
+ fixed (Vector64<Int64>* 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<Vector128<Int64>>() / sizeof(Int64);
+ private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<Int64>>() / sizeof(Int64);
+ private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<Int64>>() / 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<Int64> _clsVar1;
+ private static Vector64<Int64> _clsVar3;
+
+ private Vector128<Int64> _fld1;
+ private Vector64<Int64> _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<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int64>, byte>(ref _clsVar3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
+ }
+
+ 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<Vector128<Int64>, byte>(ref _fld1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int64>, byte>(ref _fld3), ref Unsafe.As<Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
+
+ 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<Vector128<Int64>>(_dataTable.inArray1Ptr),
+ 1,
+ Unsafe.Read<Vector64<Int64>>(_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<Int64>), typeof(byte), typeof(Vector64<Int64>) })
+ .Invoke(null, new object[] {
+ Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
+ ElementIndex,
+ Unsafe.Read<Vector64<Int64>>(_dataTable.inArray3Ptr)
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(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<Int64>), typeof(byte), typeof(Vector64<Int64>) })
+ .Invoke(null, new object[] {
+ AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
+ ElementIndex,
+ AdvSimd.LoadVector64((Int64*)(_dataTable.inArray3Ptr))
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(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<Int64>* pClsVar1 = &_clsVar1)
+ fixed (Vector64<Int64>* 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<Vector128<Int64>>(_dataTable.inArray1Ptr);
+ var op3 = Unsafe.Read<Vector64<Int64>>(_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<Int64>* pFld1 = &test._fld1)
+ fixed (Vector64<Int64>* 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<Int64>* pFld1 = &_fld1)
+ fixed (Vector64<Int64>* 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<Int64> op1, Vector64<Int64> 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<Int64, byte>(ref inArray1[0]), op1);
+ Unsafe.WriteUnaligned(ref Unsafe.As<Int64, byte>(ref inArray3[0]), op3);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+
+ 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<Int64, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<Int64>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+
+ 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)}<Int64>(Vector128<Int64>, 1, Vector64<Int64>): {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;
+ }
+ }
+ }
+}
--- /dev/null
+// 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<UInt64>();
+ int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<UInt64>();
+ int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<UInt64>();
+ 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<byte>(inArray1Ptr), ref Unsafe.As<UInt64, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<UInt64, 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 Vector128<UInt64> _fld1;
+ public Vector64<UInt64> _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<Vector128<UInt64>, byte>(ref testStruct._fld1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt64>, byte>(ref testStruct._fld3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
+
+ 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<UInt64>* pFld1 = &_fld1)
+ fixed (Vector64<UInt64>* 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<Vector128<UInt64>>() / sizeof(UInt64);
+ private static readonly int Op3ElementCount = Unsafe.SizeOf<Vector64<UInt64>>() / sizeof(UInt64);
+ private static readonly int RetElementCount = Unsafe.SizeOf<Vector128<UInt64>>() / 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<UInt64> _clsVar1;
+ private static Vector64<UInt64> _clsVar3;
+
+ private Vector128<UInt64> _fld1;
+ private Vector64<UInt64> _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<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt64>, byte>(ref _clsVar3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
+ }
+
+ 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<Vector128<UInt64>, byte>(ref _fld1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+ for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); }
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt64>, byte>(ref _fld3), ref Unsafe.As<UInt64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
+
+ 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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
+ 1,
+ Unsafe.Read<Vector64<UInt64>>(_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<UInt64>), typeof(byte), typeof(Vector64<UInt64>) })
+ .Invoke(null, new object[] {
+ Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
+ ElementIndex,
+ Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray3Ptr)
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt64>)(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<UInt64>), typeof(byte), typeof(Vector64<UInt64>) })
+ .Invoke(null, new object[] {
+ AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
+ ElementIndex,
+ AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray3Ptr))
+ });
+
+ Unsafe.Write(_dataTable.outArrayPtr, (Vector128<UInt64>)(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<UInt64>* pClsVar1 = &_clsVar1)
+ fixed (Vector64<UInt64>* 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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
+ var op3 = Unsafe.Read<Vector64<UInt64>>(_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<UInt64>* pFld1 = &test._fld1)
+ fixed (Vector64<UInt64>* 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<UInt64>* pFld1 = &_fld1)
+ fixed (Vector64<UInt64>* 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<UInt64> op1, Vector64<UInt64> 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<UInt64, byte>(ref inArray1[0]), op1);
+ Unsafe.WriteUnaligned(ref Unsafe.As<UInt64, byte>(ref inArray3[0]), op3);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+
+ 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<UInt64, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+
+ 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)}<UInt64>(Vector128<UInt64>, 1, Vector64<UInt64>): {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;
+ }
+ }
+ }
+}
["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,
["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,
};
}
}
static Program()
{
TestList = new Dictionary<string, Action>() {
+ ["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,
["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,
};
}
}
static Program()
{
TestList = new Dictionary<string, Action>() {
+ ["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,
["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,
["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,
["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,
["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,
};
}
}
static Program()
{
TestList = new Dictionary<string, Action>() {
+ ["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,
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte
{
private struct DataTable
{
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<Byte>* pFld1 = &_fld1)
fixed (Vector128<Byte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Byte*)(pFld1)),
AdvSimd.LoadVector128((Byte*)(pFld2)),
4
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<Vector128<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Byte>, byte>(ref _clsVar2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Byte>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray2Ptr),
4
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Byte>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Byte*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
4
fixed (Vector128<Byte>* pClsVar1 = &_clsVar1)
fixed (Vector128<Byte>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Byte*)(pClsVar1)),
AdvSimd.LoadVector128((Byte*)(pClsVar2)),
4
var op1 = Unsafe.Read<Vector128<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<Byte>* pFld1 = &test._fld1)
fixed (Vector128<Byte>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Byte*)(pFld1)),
AdvSimd.LoadVector128((Byte*)(pFld2)),
4
{
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);
fixed (Vector128<Byte>* pFld1 = &_fld1)
fixed (Vector128<Byte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Byte*)(pFld1)),
AdvSimd.LoadVector128((Byte*)(pFld2)),
4
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Byte>(Vector128<Byte>, Vector128<Byte>, 4): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Byte>(Vector128<Byte>, Vector128<Byte>, 4): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16
{
private struct DataTable
{
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<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
8
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<Vector128<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int16>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
8
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
8
fixed (Vector128<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int16*)(pClsVar1)),
AdvSimd.LoadVector128((Int16*)(pClsVar2)),
8
var op1 = Unsafe.Read<Vector128<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<Int16>* pFld1 = &test._fld1)
fixed (Vector128<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
8
{
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);
fixed (Vector128<Int16>* pFld1 = &_fld1)
fixed (Vector128<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int16*)(pFld1)),
AdvSimd.LoadVector128((Int16*)(pFld2)),
8
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Int16>(Vector128<Int16>, Vector128<Int16>, 8): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Int16>(Vector128<Int16>, Vector128<Int16>, 8): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32
{
private struct DataTable
{
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<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
16
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<Vector128<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int32>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
16
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
16
fixed (Vector128<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int32*)(pClsVar1)),
AdvSimd.LoadVector128((Int32*)(pClsVar2)),
16
var op1 = Unsafe.Read<Vector128<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<Int32>* pFld1 = &test._fld1)
fixed (Vector128<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
16
{
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);
fixed (Vector128<Int32>* pFld1 = &_fld1)
fixed (Vector128<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int32*)(pFld1)),
AdvSimd.LoadVector128((Int32*)(pFld2)),
16
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Int32>(Vector128<Int32>, Vector128<Int32>, 16): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Int32>(Vector128<Int32>, Vector128<Int32>, 16): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64
{
private struct DataTable
{
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<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
32
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<Vector128<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<Int64>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
32
fixed (Vector128<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector128<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int64*)(pClsVar1)),
AdvSimd.LoadVector128((Int64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector128<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<Int64>* pFld1 = &test._fld1)
fixed (Vector128<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
32
{
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);
fixed (Vector128<Int64>* pFld1 = &_fld1)
fixed (Vector128<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((Int64*)(pFld1)),
AdvSimd.LoadVector128((Int64*)(pFld2)),
32
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Int64>(Vector128<Int64>, Vector128<Int64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Int64>(Vector128<Int64>, Vector128<Int64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte
{
private struct DataTable
{
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<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((SByte*)(pFld1)),
AdvSimd.LoadVector128((SByte*)(pFld2)),
4
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<Vector128<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<SByte>, byte>(ref _clsVar2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<SByte>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr),
4
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((SByte*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
4
fixed (Vector128<SByte>* pClsVar1 = &_clsVar1)
fixed (Vector128<SByte>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((SByte*)(pClsVar1)),
AdvSimd.LoadVector128((SByte*)(pClsVar2)),
4
var op1 = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<SByte>* pFld1 = &test._fld1)
fixed (Vector128<SByte>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((SByte*)(pFld1)),
AdvSimd.LoadVector128((SByte*)(pFld2)),
4
{
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);
fixed (Vector128<SByte>* pFld1 = &_fld1)
fixed (Vector128<SByte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((SByte*)(pFld1)),
AdvSimd.LoadVector128((SByte*)(pFld2)),
4
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<SByte>(Vector128<SByte>, Vector128<SByte>, 4): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<SByte>(Vector128<SByte>, Vector128<SByte>, 4): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16
{
private struct DataTable
{
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<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
8
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<Vector128<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
8
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
8
fixed (Vector128<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt16*)(pClsVar1)),
AdvSimd.LoadVector128((UInt16*)(pClsVar2)),
8
var op1 = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<UInt16>* pFld1 = &test._fld1)
fixed (Vector128<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
8
{
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);
fixed (Vector128<UInt16>* pFld1 = &_fld1)
fixed (Vector128<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt16*)(pFld1)),
AdvSimd.LoadVector128((UInt16*)(pFld2)),
8
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>, 8): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>, 8): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32
{
private struct DataTable
{
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<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
16
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<Vector128<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
16
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
16
fixed (Vector128<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt32*)(pClsVar1)),
AdvSimd.LoadVector128((UInt32*)(pClsVar2)),
16
var op1 = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<UInt32>* pFld1 = &test._fld1)
fixed (Vector128<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
16
{
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);
fixed (Vector128<UInt32>* pFld1 = &_fld1)
fixed (Vector128<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt32*)(pFld1)),
AdvSimd.LoadVector128((UInt32*)(pFld2)),
16
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>, 16): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>, 16): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64
{
private struct DataTable
{
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<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
32
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<Vector128<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector128<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
32
fixed (Vector128<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector128<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt64*)(pClsVar1)),
AdvSimd.LoadVector128((UInt64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector128<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);
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);
{
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);
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<UInt64>* pFld1 = &test._fld1)
fixed (Vector128<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
32
{
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);
fixed (Vector128<UInt64>* pFld1 = &_fld1)
fixed (Vector128<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector128((UInt64*)(pFld1)),
AdvSimd.LoadVector128((UInt64*)(pFld2)),
32
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte
{
private struct DataTable
{
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<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector64((Byte*)(pFld2)),
4
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<Vector64<Byte>, byte>(ref _clsVar1), ref Unsafe.As<Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Byte>, byte>(ref _clsVar2), ref Unsafe.As<Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Byte>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr),
4
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Byte>), typeof(Vector64<Byte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Byte>), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Byte>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Byte>), typeof(Vector64<Byte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Byte>), typeof(Vector64<Byte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Byte*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
4
fixed (Vector64<Byte>* pClsVar1 = &_clsVar1)
fixed (Vector64<Byte>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Byte*)(pClsVar1)),
AdvSimd.LoadVector64((Byte*)(pClsVar2)),
4
var op1 = Unsafe.Read<Vector64<Byte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<Byte>* pFld1 = &test._fld1)
fixed (Vector64<Byte>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector64((Byte*)(pFld2)),
4
{
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);
fixed (Vector64<Byte>* pFld1 = &_fld1)
fixed (Vector64<Byte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Byte*)(pFld1)),
AdvSimd.LoadVector64((Byte*)(pFld2)),
4
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Byte>(Vector64<Byte>, Vector64<Byte>, 4): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Byte>(Vector64<Byte>, Vector64<Byte>, 4): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16
{
private struct DataTable
{
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<Int16>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
8
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<Vector64<Int16>, byte>(ref _clsVar1), ref Unsafe.As<Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int16>, byte>(ref _clsVar2), ref Unsafe.As<Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int16>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
8
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Int16>), typeof(Vector64<Int16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
8
fixed (Vector64<Int16>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int16*)(pClsVar1)),
AdvSimd.LoadVector64((Int16*)(pClsVar2)),
8
var op1 = Unsafe.Read<Vector64<Int16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<Int16>* pFld1 = &test._fld1)
fixed (Vector64<Int16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
8
{
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);
fixed (Vector64<Int16>* pFld1 = &_fld1)
fixed (Vector64<Int16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int16*)(pFld1)),
AdvSimd.LoadVector64((Int16*)(pFld2)),
8
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Int16>(Vector64<Int16>, Vector64<Int16>, 8): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Int16>(Vector64<Int16>, Vector64<Int16>, 8): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32
{
private struct DataTable
{
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<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int32*)(pFld2)),
16
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<Vector64<Int32>, byte>(ref _clsVar1), ref Unsafe.As<Int32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int32>, byte>(ref _clsVar2), ref Unsafe.As<Int32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int32>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray2Ptr),
16
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Int32>), typeof(Vector64<Int32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Int32>), typeof(Vector64<Int32>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<Int32>), typeof(Vector64<Int32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<Int32>), typeof(Vector64<Int32>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
16
fixed (Vector64<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int32*)(pClsVar1)),
AdvSimd.LoadVector64((Int32*)(pClsVar2)),
16
var op1 = Unsafe.Read<Vector64<Int32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<Int32>* pFld1 = &test._fld1)
fixed (Vector64<Int32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int32*)(pFld2)),
16
{
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);
fixed (Vector64<Int32>* pFld1 = &_fld1)
fixed (Vector64<Int32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((Int32*)(pFld1)),
AdvSimd.LoadVector64((Int32*)(pFld2)),
16
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<Int32>(Vector64<Int32>, Vector64<Int32>, 16): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<Int32>(Vector64<Int32>, Vector64<Int32>, 16): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte
{
private struct DataTable
{
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<SByte>* pFld1 = &_fld1)
fixed (Vector64<SByte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector64((SByte*)(pFld2)),
4
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<Vector64<SByte>, byte>(ref _clsVar1), ref Unsafe.As<SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<SByte>, byte>(ref _clsVar2), ref Unsafe.As<SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<SByte>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray2Ptr),
4
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<SByte>), typeof(Vector64<SByte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<SByte>), typeof(Vector64<SByte>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<SByte>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<SByte>), typeof(Vector64<SByte>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<SByte>), typeof(Vector64<SByte>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((SByte*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
4
fixed (Vector64<SByte>* pClsVar1 = &_clsVar1)
fixed (Vector64<SByte>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((SByte*)(pClsVar1)),
AdvSimd.LoadVector64((SByte*)(pClsVar2)),
4
var op1 = Unsafe.Read<Vector64<SByte>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<SByte>* pFld1 = &test._fld1)
fixed (Vector64<SByte>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector64((SByte*)(pFld2)),
4
{
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);
fixed (Vector64<SByte>* pFld1 = &_fld1)
fixed (Vector64<SByte>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((SByte*)(pFld1)),
AdvSimd.LoadVector64((SByte*)(pFld2)),
4
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<SByte>(Vector64<SByte>, Vector64<SByte>, 4): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<SByte>(Vector64<SByte>, Vector64<SByte>, 4): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16
{
private struct DataTable
{
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<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
8
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<Vector64<UInt16>, byte>(ref _clsVar1), ref Unsafe.As<UInt16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt16>, byte>(ref _clsVar2), ref Unsafe.As<UInt16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
8
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<UInt16>), typeof(Vector64<UInt16>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
8
fixed (Vector64<UInt16>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt16>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt16*)(pClsVar1)),
AdvSimd.LoadVector64((UInt16*)(pClsVar2)),
8
var op1 = Unsafe.Read<Vector64<UInt16>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<UInt16>* pFld1 = &test._fld1)
fixed (Vector64<UInt16>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
8
{
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);
fixed (Vector64<UInt16>* pFld1 = &_fld1)
fixed (Vector64<UInt16>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt16*)(pFld1)),
AdvSimd.LoadVector64((UInt16*)(pFld2)),
8
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<UInt16>(Vector64<UInt16>, Vector64<UInt16>, 8): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<UInt16>(Vector64<UInt16>, Vector64<UInt16>, 8): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32
{
private struct DataTable
{
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<UInt32>* pFld1 = &_fld1)
fixed (Vector64<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector64((UInt32*)(pFld2)),
16
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<Vector64<UInt32>, byte>(ref _clsVar1), ref Unsafe.As<UInt32, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt32>, byte>(ref _clsVar2), ref Unsafe.As<UInt32, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32()
+ public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray2Ptr),
16
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<UInt32>), typeof(Vector64<UInt32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<UInt32>), typeof(Vector64<UInt32>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64<UInt32>), typeof(Vector64<UInt32>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64<UInt32>), typeof(Vector64<UInt32>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
_clsVar1,
_clsVar2,
16
fixed (Vector64<UInt32>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt32>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt32*)(pClsVar1)),
AdvSimd.LoadVector64((UInt32*)(pClsVar2)),
16
var op1 = Unsafe.Read<Vector64<UInt32>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<UInt32>* pFld1 = &test._fld1)
fixed (Vector64<UInt32>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector64((UInt32*)(pFld2)),
16
{
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);
fixed (Vector64<UInt32>* pFld1 = &_fld1)
fixed (Vector64<UInt32>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsert(
+ var result = AdvSimd.ShiftLeftAndInsert(
AdvSimd.LoadVector64((UInt32*)(pFld1)),
AdvSimd.LoadVector64((UInt32*)(pFld2)),
16
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);
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
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;
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}<UInt32>(Vector64<UInt32>, Vector64<UInt32>, 16): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}<UInt32>(Vector64<UInt32>, Vector64<UInt32>, 16): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64
{
private struct DataTable
{
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<Int64>* pFld1 = &_fld1)
fixed (Vector64<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
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<Vector64<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64()
+ public ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
_clsVar1,
_clsVar2,
32
fixed (Vector64<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pClsVar1)),
AdvSimd.LoadVector64((Int64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<Int64>* pFld1 = &test._fld1)
fixed (Vector64<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
{
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);
fixed (Vector64<Int64>* pFld1 = &_fld1)
fixed (Vector64<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
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);
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
{
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;
}
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar)}<Int64>(Vector64<Int64>, Vector64<Int64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsertScalar)}<Int64>(Vector64<Int64>, Vector64<Int64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64
+ public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64
{
private struct DataTable
{
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<UInt64>* pFld1 = &_fld1)
fixed (Vector64<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
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<Vector64<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
}
- public ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64()
+ public ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
_clsVar1,
_clsVar2,
32
fixed (Vector64<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pClsVar1)),
AdvSimd.LoadVector64((UInt64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<UInt64>* pFld1 = &test._fld1)
fixed (Vector64<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
{
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);
fixed (Vector64<UInt64>* pFld1 = &_fld1)
fixed (Vector64<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftLeftAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
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);
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
{
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;
}
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar)}<UInt64>(Vector64<UInt64>, Vector64<UInt64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsertScalar)}<UInt64>(Vector64<UInt64>, Vector64<UInt64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64
+ public sealed unsafe class ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64
{
private struct DataTable
{
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<Int64>* pFld1 = &_fld1)
fixed (Vector64<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
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<Vector64<Int64>, byte>(ref _clsVar1), ref Unsafe.As<Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<Int64>, byte>(ref _clsVar2), ref Unsafe.As<Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<Int64>>());
}
- public ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64()
+ public ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<Int64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64<Int64>), typeof(Vector64<Int64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
_clsVar1,
_clsVar2,
32
fixed (Vector64<Int64>* pClsVar1 = &_clsVar1)
fixed (Vector64<Int64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pClsVar1)),
AdvSimd.LoadVector64((Int64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector64<Int64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<Int64>* pFld1 = &test._fld1)
fixed (Vector64<Int64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
{
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);
fixed (Vector64<Int64>* pFld1 = &_fld1)
fixed (Vector64<Int64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((Int64*)(pFld1)),
AdvSimd.LoadVector64((Int64*)(pFld2)),
32
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);
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
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAndInsertScalar)}<Int64>(Vector64<Int64>, Vector64<Int64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightAndInsertScalar)}<Int64>(Vector64<Int64>, Vector64<Int64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
{
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)
{
}
}
- public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64
+ public sealed unsafe class ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64
{
private struct DataTable
{
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<UInt64>* pFld1 = &_fld1)
fixed (Vector64<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
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<Vector64<UInt64>, byte>(ref _clsVar1), ref Unsafe.As<UInt64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
Unsafe.CopyBlockUnaligned(ref Unsafe.As<Vector64<UInt64>, byte>(ref _clsVar2), ref Unsafe.As<UInt64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<Vector64<UInt64>>());
}
- public ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64()
+ public ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64()
{
Succeeded = true;
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray2Ptr),
32
{
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
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr),
Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray2Ptr),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
- var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
+ var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64<UInt64>), typeof(Vector64<UInt64>), typeof(byte) })
.Invoke(null, new object[] {
AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)),
AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)),
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
_clsVar1,
_clsVar2,
32
fixed (Vector64<UInt64>* pClsVar1 = &_clsVar1)
fixed (Vector64<UInt64>* pClsVar2 = &_clsVar2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pClsVar1)),
AdvSimd.LoadVector64((UInt64*)(pClsVar2)),
32
var op1 = Unsafe.Read<Vector64<UInt64>>(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read<Vector64<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);
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);
{
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);
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<UInt64>* pFld1 = &test._fld1)
fixed (Vector64<UInt64>* pFld2 = &test._fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
{
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);
fixed (Vector64<UInt64>* pFld1 = &_fld1)
fixed (Vector64<UInt64>* pFld2 = &_fld2)
{
- var result = AdvSimd.ShiftRightLogicalAndInsertScalar(
+ var result = AdvSimd.ShiftRightAndInsertScalar(
AdvSimd.LoadVector64((UInt64*)(pFld1)),
AdvSimd.LoadVector64((UInt64*)(pFld2)),
32
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);
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
if (!succeeded)
{
- TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAndInsertScalar)}<UInt64>(Vector64<UInt64>, Vector64<UInt64>, 32): {method} failed:");
+ TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightAndInsertScalar)}<UInt64>(Vector64<UInt64>, Vector64<UInt64>, 32): {method} failed:");
TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})");
TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
("InsertTest.template", new Dictionary<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),
("VecBinOpTest.template", new Dictionary<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),
("VecImmUnOpTest.template", new Dictionary<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),
("VecImmBinOpTest.template", new Dictionary<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),
("VecImmBinOpTest.template", new Dictionary<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),
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);
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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);
(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;
}
--- /dev/null
+// 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<byte>(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+ Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(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<byte>(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<byte>(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>());
+ Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(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;
+ }
+ }
+ }
+}
public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
/// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<double> InsertScalar(Vector128<double> result, byte resultIndex, Vector64<double> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<long> InsertScalar(Vector128<long> result, byte resultIndex, Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<ulong> InsertScalar(Vector128<ulong> result, byte resultIndex, Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
/// int16x4_t vcls_s16 (int16x4_t a)
/// A32: VCLS.S16 Dd, Dm
/// A64: CLS Vd.4H, Vn.4H
public static Vector64<float> RoundToZeroScalar(Vector64<float> value) { throw new PlatformNotSupportedException(); }
/// <summary>
- /// 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
- /// </summary>
- public static Vector64<byte> ShiftLeftLogicalAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<short> ShiftLeftLogicalAndInsert(Vector64<short> left, Vector64<short> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<int> ShiftLeftLogicalAndInsert(Vector64<int> left, Vector64<int> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<sbyte> ShiftLeftLogicalAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ushort> ShiftLeftLogicalAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<uint> ShiftLeftLogicalAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<byte> ShiftLeftLogicalAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<short> ShiftLeftLogicalAndInsert(Vector128<short> left, Vector128<short> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<int> ShiftLeftLogicalAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<long> ShiftLeftLogicalAndInsert(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<sbyte> ShiftLeftLogicalAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ushort> ShiftLeftLogicalAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<uint> ShiftLeftLogicalAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ulong> ShiftLeftLogicalAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<long> ShiftLeftLogicalAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ulong> ShiftLeftLogicalAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<long> ShiftRightLogicalAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ulong> ShiftRightLogicalAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
-
- /// <summary>
/// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b)
/// A32: VSHL.S16 Dd, Dn, Dm
/// A64: SSHL Vd.4H, Vn.4H, Vm.4H
public static Vector64<long> ShiftArithmeticScalar(Vector64<long> value, Vector64<long> count) { throw new PlatformNotSupportedException(); }
/// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
/// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n)
/// A32: VSHL.I8 Dd, Dm, #n
/// A64: SHL Vd.8B, Vn.8B, #n
public static Vector64<ulong> ShiftLogicalScalar(Vector64<ulong> value, Vector64<long> count) { throw new PlatformNotSupportedException(); }
/// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
/// int16x4_t vshr_n_s16 (int16x4_t a, const int n)
/// A32: VSHR.S16 Dd, Dm, #n
/// A64: SSHR Vd.4H, Vn.4H, #n
public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) => Insert(vector, index, data);
/// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<double> InsertScalar(Vector128<double> result, byte resultIndex, Vector64<double> value) => InsertScalar(result, resultIndex, value);
+
+ /// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<long> InsertScalar(Vector128<long> result, byte resultIndex, Vector64<long> value) => InsertScalar(result, resultIndex, value);
+
+ /// <summary>
+ /// 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]
+ /// </summary>
+ public static Vector128<ulong> InsertScalar(Vector128<ulong> result, byte resultIndex, Vector64<ulong> value) => InsertScalar(result, resultIndex, value);
+
+ /// <summary>
/// int16x4_t vcls_s16 (int16x4_t a)
/// A32: VCLS.S16 Dd, Dm
/// A64: CLS Vd.4H, Vn.4H
public static Vector64<float> RoundToZeroScalar(Vector64<float> value) => RoundToZeroScalar(value);
/// <summary>
- /// 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
- /// </summary>
- public static Vector64<byte> ShiftLeftLogicalAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<short> ShiftLeftLogicalAndInsert(Vector64<short> left, Vector64<short> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<int> ShiftLeftLogicalAndInsert(Vector64<int> left, Vector64<int> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<sbyte> ShiftLeftLogicalAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ushort> ShiftLeftLogicalAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<uint> ShiftLeftLogicalAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<byte> ShiftLeftLogicalAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<short> ShiftLeftLogicalAndInsert(Vector128<short> left, Vector128<short> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<int> ShiftLeftLogicalAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<long> ShiftLeftLogicalAndInsert(Vector128<long> left, Vector128<long> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<sbyte> ShiftLeftLogicalAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ushort> ShiftLeftLogicalAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<uint> ShiftLeftLogicalAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ulong> ShiftLeftLogicalAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<long> ShiftLeftLogicalAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) => ShiftLeftLogicalAndInsertScalar(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ulong> ShiftLeftLogicalAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) => ShiftLeftLogicalAndInsertScalar(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftRightAndInsert(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<long> ShiftRightLogicalAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) => ShiftRightLogicalAndInsertScalar(left, right, shift);
-
- /// <summary>
- /// 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
- /// </summary>
- public static Vector64<ulong> ShiftRightLogicalAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) => ShiftRightLogicalAndInsertScalar(left, right, shift);
-
- /// <summary>
/// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b)
/// A32: VSHL.S16 Dd, Dn, Dm
/// A64: SSHL Vd.4H, Vn.4H, Vm.4H
public static Vector64<long> ShiftArithmeticScalar(Vector64<long> value, Vector64<long> count) => ShiftArithmeticScalar(value, count);
/// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+
+ /// <summary>
/// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n)
/// A32: VSHL.I8 Dd, Dm, #n
/// A64: SHL Vd.8B, Vn.8B, #n
public static Vector64<ulong> ShiftLogicalScalar(Vector64<ulong> value, Vector64<long> count) => ShiftLogicalScalar(value, count);
/// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+
+ /// <summary>
+ /// 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
+ /// </summary>
+ public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+
+ /// <summary>
/// int16x4_t vshr_n_s16 (int16x4_t a, const int n)
/// A32: VSHR.S16 Dd, Dm, #n
/// A64: SSHR Vd.4H, Vn.4H, #n
public static Vector128<T> WithLower<T>(this Vector128<T> vector, Vector64<T> value)
where T : struct
{
- if (AdvSimd.Arm64.IsSupported)
+ if (AdvSimd.IsSupported)
{
- return AdvSimd.
Arm64.InsertSelectedScalar(vector.AsUInt64(), 0, value.ToVector128Unsafe().AsUInt64(), 0).As<ulong, T>();
+ return AdvSimd.
InsertScalar(vector.AsUInt64(), 0, value.AsUInt64()).As<ulong, T>();
}
return SoftwareFallback(vector, value);
public static Vector128<T> WithUpper<T>(this Vector128<T> vector, Vector64<T> value)
where T : struct
{
- if (AdvSimd.Arm64.IsSupported)
+ if (AdvSimd.IsSupported)
{
- return AdvSimd.
Arm64.InsertSelectedScalar(vector.AsUInt64(), 1, value.ToVector128Unsafe().AsUInt64(), 0).As<ulong, T>();
+ return AdvSimd.
InsertScalar(vector.AsUInt64(), 1, value.AsUInt64()).As<ulong, T>();
}
return SoftwareFallback(vector, value);
public static System.Runtime.Intrinsics.Vector64<float> Insert(System.Runtime.Intrinsics.Vector64<float> vector, byte index, float data) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ushort> Insert(System.Runtime.Intrinsics.Vector64<ushort> vector, byte index, ushort data) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> Insert(System.Runtime.Intrinsics.Vector64<uint> vector, byte index, uint data) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<double> InsertScalar(System.Runtime.Intrinsics.Vector128<double> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<long> InsertScalar(System.Runtime.Intrinsics.Vector128<long> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ulong> InsertScalar(System.Runtime.Intrinsics.Vector128<ulong> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> LeadingSignCount(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> LeadingSignCount(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
public static System.Runtime.Intrinsics.Vector128<sbyte> LeadingSignCount(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftArithmeticSaturate(System.Runtime.Intrinsics.Vector64<sbyte> value, System.Runtime.Intrinsics.Vector64<sbyte> count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<long> ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<long> ShiftArithmeticScalar(System.Runtime.Intrinsics.Vector64<long> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<long> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
+ public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
- public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
projects / platform / upstream / dotnet / runtime.git / commitdiff