* Adding support for Vector512 bitwise operations: And, AndNot, Or, OnesComplement, and Xor
* Adding AVX512F APIs for And, AndNot, Load, Or, Store, and Xor
* Fix the "throw new PlatformNotSupported" expressions for Avx512F
* Fixing some test build failures
* Ensure the Avx512F and related classes can lightup in import
* Ensure that JitStressEvexEncoding is only checked in debug
* Allow 64-bit alignment in the test data table types and fix the AVX512 enablement check
instructionSetFlags.HasInstructionSet(InstructionSet_AVX512BW) &&
instructionSetFlags.HasInstructionSet(InstructionSet_AVX512DQ))
{
- if (!DoJitStressEvexEncoding())
+ // Using JitStressEVEXEncoding flag will force instructions which would
+ // otherwise use VEX encoding but can be EVEX encoded to use EVEX encoding
+ // This requires AVX512VL support. JitForceEVEXEncoding forces this encoding, thus
+ // causing failure if not running on compatible hardware.
+
+ // We can't use !DoJitStressEvexEncoding() yet because opts.compSupportsISA hasn't
+ // been set yet as that's what we're trying to set here
+
+ bool enableAvx512 = false;
+
+#if defined(DEBUG)
+ if (JitConfig.JitForceEVEXEncoding())
+ {
+ enableAvx512 = true;
+ }
+ else if (JitConfig.JitStressEvexEncoding() && instructionSetFlags.HasInstructionSet(InstructionSet_AVX512F_VL))
+ {
+ enableAvx512 = true;
+ }
+#endif // DEBUG
+
+ if (!enableAvx512)
{
instructionSetFlags.RemoveInstructionSet(InstructionSet_AVX512F);
instructionSetFlags.RemoveInstructionSet(InstructionSet_AVX512F_VL);
// Since we are not using k registers yet, this will have no impact on correctness but will affect things
// once
// k registers are used (as that is the point of the "break out operand type" of these instructions)
- // case INS_movdqa: // INS_movdqa32, INS_movdqa64.
- // case INS_movdqu: // INS_movdqu8, INS_movdqu16, INS_movdqu32, INS_movdqu64.
- // case INS_pand: // INS_pandd, INS_pandq.
- // case INS_pandn: // INS_pandnd, INS_pandnq.
- // case INS_por: // INS_pord, INS_porq.
- // case INS_pxor: // INS_pxord, INS_pxorq
+ // case INS_movdqa: // INS_vmovdqa32, INS_vmovdqa64.
+ // case INS_movdqu: // INS_movdqu8, INS_movdqu16, INS_vmovdqu32, INS_vmovdqu64.
+ // case INS_pand: // INS_vpandd, INS_vpandq.
+ // case INS_pandn: // INS_vpandnd, INS_vpandnq.
+ // case INS_por: // INS_vpord, INS_vporq.
+ // case INS_pxor: // INS_vpxord, INS_vpxorq
// case INS_vextractf128: // INS_vextractf32x4, INS_vextractf64x2.
// case INS_vextracti128: // INS_vextracti32x4, INS_vextracti64x2.
// case INS_vinsertf128: // INS_vinsertf32x4, INS_vinsertf64x2.
return true;
}
+//------------------------------------------------------------------------
+// IsRexW0Instruction: check if the instruction always encodes REX.W as 0
+//
+// Arguments:
+// id - instruction to test
+//
+// Return Value:
+// true if the instruction always encodes REX.W as 0; othwerwise, false
+//
+bool emitter::IsRexW0Instruction(instruction ins)
+{
+ insFlags flags = CodeGenInterface::instInfo[ins];
+
+ if ((flags & REX_W0) != 0)
+ {
+ assert((flags & (REX_W1 | REX_WX)) == 0);
+ return true;
+ }
+
+ return false;
+}
+
+//------------------------------------------------------------------------
+// IsRexW1Instruction: check if the instruction always encodes REX.W as 1
+//
+// Arguments:
+// id - instruction to test
+//
+// Return Value:
+// true if the instruction always encodes REX.W as 1; othwerwise, false
+//
+bool emitter::IsRexW1Instruction(instruction ins)
+{
+ insFlags flags = CodeGenInterface::instInfo[ins];
+
+ if ((flags & REX_W1) != 0)
+ {
+ assert((flags & (REX_W0 | REX_WX)) == 0);
+ return true;
+ }
+
+ return false;
+}
+
+//------------------------------------------------------------------------
+// IsRexWXInstruction: check if the instruction requires special REX.W encoding
+//
+// Arguments:
+// id - instruction to test
+//
+// Return Value:
+// true if the instruction requires special REX.W encoding; othwerwise, false
+//
+bool emitter::IsRexWXInstruction(instruction ins)
+{
+ insFlags flags = CodeGenInterface::instInfo[ins];
+
+ if ((flags & REX_WX) != 0)
+ {
+ assert((flags & (REX_W0 | REX_W1)) == 0);
+ return true;
+ }
+
+ return false;
+}
+
#ifdef TARGET_64BIT
//------------------------------------------------------------------------
// AreUpper32BitsZero: check if some previously emitted
case INS_movaps:
case INS_movd:
case INS_movdqa:
- case INS_movdqa32:
- case INS_movdqa64:
+ case INS_vmovdqa32:
+ case INS_vmovdqa64:
case INS_movdqu:
case INS_movdqu8:
case INS_movdqu16:
- case INS_movdqu32:
- case INS_movdqu64:
+ case INS_vmovdqu32:
+ case INS_vmovdqu64:
case INS_movsdsse2:
case INS_movss:
case INS_movsx:
break;
}
- case INS_movdqa32:
- case INS_movdqa64:
+ case INS_vmovdqa32:
+ case INS_vmovdqa64:
case INS_movdqu8:
case INS_movdqu16:
- case INS_movdqu32:
- case INS_movdqu64:
+ case INS_vmovdqu32:
+ case INS_vmovdqu64:
{
// These EVEX instructions merges/masks based on k-register
// TODO-XArch-AVX512 : Handle merge/masks scenarios once k-mask support is added for these.
case INS_movapd:
case INS_movaps:
case INS_movdqa:
- case INS_movdqa32:
- case INS_movdqa64:
+ case INS_vmovdqa32:
+ case INS_vmovdqa64:
case INS_movdqu:
case INS_movdqu8:
case INS_movdqu16:
- case INS_movdqu32:
- case INS_movdqu64:
+ case INS_vmovdqu32:
+ case INS_vmovdqu64:
case INS_movsdsse2:
case INS_movss:
case INS_movupd:
break;
case INS_movdqa:
- case INS_movdqa32:
- case INS_movdqa64:
+ case INS_vmovdqa32:
+ case INS_vmovdqa64:
case INS_movdqu:
case INS_movdqu8:
case INS_movdqu16:
- case INS_movdqu32:
- case INS_movdqu64:
+ case INS_vmovdqu32:
+ case INS_vmovdqu64:
case INS_movaps:
case INS_movups:
case INS_movapd:
case INS_paddusw:
case INS_psubusw:
case INS_pand:
+ case INS_vpandd:
+ case INS_vpandq:
case INS_pandn:
+ case INS_vpandnd:
+ case INS_vpandnq:
case INS_por:
+ case INS_vpord:
+ case INS_vporq:
case INS_pxor:
+ case INS_vpxord:
+ case INS_vpxorq:
case INS_andpd:
case INS_andps:
case INS_andnpd:
instruction ins = id->idIns();
+ if (IsRexW0Instruction(ins))
+ {
+ return false;
+ }
+ else if (IsRexW1Instruction(ins))
+ {
+ return true;
+ }
+
+ if (IsRexWXInstruction(ins))
+ {
+ // TODO: Make this a simple assert once all instructions are annotated
+ unreached();
+ }
+
switch (ins)
{
case INS_movq:
case INS_vfnmsub231sd:
case INS_unpcklpd:
case INS_vpermilpdvar:
- case INS_movdqa64:
case INS_movdqu16:
- case INS_movdqu64:
case INS_vinsertf64x4:
case INS_vinserti64x4:
{
case INS_vpdpbusds:
case INS_vpdpwssds:
case INS_vpermilpsvar:
- case INS_movdqa32:
case INS_movdqu8:
- case INS_movdqu32:
case INS_vinsertf32x8:
case INS_vinserti32x8:
{
bool DoesWriteSignFlag(instruction ins);
bool DoesResetOverflowAndCarryFlags(instruction ins);
bool IsFlagsAlwaysModified(instrDesc* id);
+static bool IsRexW0Instruction(instruction ins);
+static bool IsRexW1Instruction(instruction ins);
+static bool IsRexWXInstruction(instruction ins);
bool IsThreeOperandAVXInstruction(instruction ins)
{
case GT_AND:
{
- if (simdSize == 32)
+ if (simdSize == 64)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX512F));
+ intrinsic = NI_AVX512F_And;
+ }
+ else if (simdSize == 32)
{
assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
case GT_AND_NOT:
{
- if (simdSize == 32)
+ if (simdSize == 64)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX512F));
+ intrinsic = NI_AVX512F_AndNot;
+ }
+ else if (simdSize == 32)
{
assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
case GT_OR:
{
- if (simdSize == 32)
+ if (simdSize == 64)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX512F));
+ intrinsic = NI_AVX512F_Or;
+ }
+ else if (simdSize == 32)
{
assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
case GT_XOR:
{
- if (simdSize == 32)
+ if (simdSize == 64)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX512F));
+ intrinsic = NI_AVX512F_Xor;
+ }
+ else if (simdSize == 32)
{
assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
case GT_NOT:
{
- assert((simdSize != 32) || compIsaSupportedDebugOnly(InstructionSet_AVX));
+ if (simdSize == 64)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX512F));
+ }
+ else if (simdSize == 32)
+ {
+ assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
+ }
+
op2 = gtNewAllBitsSetConNode(type);
return gtNewSimdBinOpNode(GT_XOR, type, op1, op2, simdBaseJitType, simdSize, isSimdAsHWIntrinsic);
}
#ifdef DEBUG
CORINFO_InstructionSet isa = HWIntrinsicInfo::lookupIsa(intrinsic);
#ifdef TARGET_XARCH
- assert((isa == InstructionSet_Vector256) || (isa == InstructionSet_Vector128));
+ assert((isa == InstructionSet_Vector512) || (isa == InstructionSet_Vector256) || (isa == InstructionSet_Vector128));
#endif // TARGET_XARCH
#ifdef TARGET_ARM64
assert((isa == InstructionSet_Vector64) || (isa == InstructionSet_Vector128));
assert(numArgs >= 0);
- if (!isScalar && ((HWIntrinsicInfo::lookupIns(intrinsic, simdBaseType) == INS_invalid) ||
- ((simdSize != 8) && (simdSize != 16) && (simdSize != 32))))
+ if (!isScalar)
{
- assert(!"Unexpected HW Intrinsic");
- return nullptr;
+ if (HWIntrinsicInfo::lookupIns(intrinsic, simdBaseType) == INS_invalid)
+ {
+ assert(!"Unexpected HW intrinsic");
+ return nullptr;
+ }
+
+#if defined(TARGET_ARM64)
+ if ((simdSize != 8) && (simdSize != 16))
+#elif defined(TARGET_XARCH)
+ if ((simdSize != 16) && (simdSize != 32) && (simdSize != 64))
+#endif // TARGET_*
+ {
+ assert(!"Unexpected SIMD size");
+ return nullptr;
+ }
}
GenTree* op1 = nullptr;
HARDWARE_INTRINSIC(Vector256, Subtract, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector256, Sum, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector256, ToScalar, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movss, INS_movsdsse2}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics|HW_Flag_AvxOnlyCompatible)
-HARDWARE_INTRINSIC(Vector256, ToVector512Unsafe, 32, 1, {INS_movdqu8, INS_movdqu8, INS_movdqu16, INS_movdqu16, INS_movdqu32, INS_movdqu32, INS_movdqu64, INS_movdqu64, INS_movups, INS_movupd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(Vector256, ToVector512Unsafe, 32, 1, {INS_movdqu8, INS_movdqu8, INS_movdqu16, INS_movdqu16, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu64, INS_vmovdqu64, INS_movups, INS_movupd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(Vector256, WidenLower, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(Vector256, WidenUpper, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(Vector256, WithElement, 32, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoContainment|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
// {TYP_BYTE, TYP_UBYTE, TYP_SHORT, TYP_USHORT, TYP_INT, TYP_UINT, TYP_LONG, TYP_ULONG, TYP_FLOAT, TYP_DOUBLE}
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// Vector512 Intrinsics
+HARDWARE_INTRINSIC(Vector512, AndNot, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, BitwiseAnd, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, BitwiseOr, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, Create, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, CreateScalar, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, CreateScalarUnsafe, 64, 1, {INS_movd, INS_movd, INS_movd, INS_movd, INS_movd, INS_movd, INS_movd, INS_movd, INS_movss, INS_movsdsse2}, HW_Category_SIMDScalar, HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(Vector512, ExtractMostSignificantBits, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, get_AllBitsSet, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_ReturnsPerElementMask)
HARDWARE_INTRINSIC(Vector512, get_One, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, get_Zero, 64, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_ReturnsPerElementMask)
HARDWARE_INTRINSIC(Vector512, LoadAligned, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, LoadAlignedNonTemporal, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, LoadUnsafe, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, OnesComplement, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, op_BitwiseAnd, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_Commutative)
+HARDWARE_INTRINSIC(Vector512, op_BitwiseOr, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_Commutative)
+HARDWARE_INTRINSIC(Vector512, op_ExclusiveOr, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, op_OnesComplement, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, Store, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, StoreAligned, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, StoreAlignedNonTemporal, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
HARDWARE_INTRINSIC(Vector512, StoreUnsafe, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
-
-HARDWARE_INTRINSIC(Vector512, ExtractMostSignificantBits, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(Vector512, Xor, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// ISA Function name SIMD size NumArg Instructions Category Flags
HARDWARE_INTRINSIC(AVX2, Abs, 32, 1, {INS_pabsb, INS_invalid, INS_pabsw, INS_invalid, INS_pabsd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoRMWSemantics|HW_Flag_BaseTypeFromFirstArg)
HARDWARE_INTRINSIC(AVX2, Add, 32, 2, {INS_paddb, INS_paddb, INS_paddw, INS_paddw, INS_paddd, INS_paddd, INS_paddq, INS_paddq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AVX2, AddSaturate, 32, 2, {INS_paddsb, INS_paddusb, INS_paddsw, INS_paddusw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
-HARDWARE_INTRINSIC(AVX2, AlignRight, 32, 3, {INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM)
+HARDWARE_INTRINSIC(AVX2, AlignRight, 32, 3, {INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM)
HARDWARE_INTRINSIC(AVX2, And, 32, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AVX2, AndNot, 32, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AVX2, Average, 32, 2, {INS_invalid, INS_pavgb, INS_invalid, INS_pavgw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
HARDWARE_INTRINSIC(AVX2, UnpackHigh, 32, 2, {INS_punpckhbw, INS_punpckhbw, INS_punpckhwd, INS_punpckhwd, INS_punpckhdq, INS_punpckhdq, INS_punpckhqdq, INS_punpckhqdq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AVX2, UnpackLow, 32, 2, {INS_punpcklbw, INS_punpcklbw, INS_punpcklwd, INS_punpcklwd, INS_punpckldq, INS_punpckldq, INS_punpcklqdq, INS_punpcklqdq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AVX2, Xor, 32, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// ISA Function name SIMD size NumArg Instructions Category Flags
// {TYP_BYTE, TYP_UBYTE, TYP_SHORT, TYP_USHORT, TYP_INT, TYP_UINT, TYP_LONG, TYP_ULONG, TYP_FLOAT, TYP_DOUBLE}
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// AVX512F Intrinsics
+HARDWARE_INTRINSIC(AVX512F, And, 64, 2, {INS_vpandd, INS_vpandd, INS_vpandd, INS_vpandd, INS_vpandd, INS_vpandd, INS_vpandq, INS_vpandq, INS_andps, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+HARDWARE_INTRINSIC(AVX512F, AndNot, 64, 2, {INS_vpandnd, INS_vpandnd, INS_vpandnd, INS_vpandnd, INS_vpandnd, INS_vpandnd, INS_vpandnq, INS_vpandnq, INS_andnps, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag)
HARDWARE_INTRINSIC(AVX512F, BroadcastScalarToVector512, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpbroadcastd, INS_vpbroadcastd, INS_vpbroadcastq, INS_vpbroadcastq, INS_vbroadcastss, INS_vbroadcastsd}, HW_Category_SIMDScalar, HW_Flag_MaybeMemoryLoad)
HARDWARE_INTRINSIC(AVX512F, InsertVector256, 64, 3, {INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinsertf64x4, INS_vinsertf64x4}, HW_Category_IMM, HW_Flag_FullRangeIMM)
-HARDWARE_INTRINSIC(AVX512F, LoadAlignedVector512, 64, 1, {INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa64, INS_movdqa64, INS_movaps, INS_movapd}, HW_Category_MemoryLoad, HW_Flag_NoRMWSemantics)
+HARDWARE_INTRINSIC(AVX512F, LoadAlignedVector512, 64, 1, {INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa64, INS_vmovdqa64, INS_movaps, INS_movapd}, HW_Category_MemoryLoad, HW_Flag_NoRMWSemantics)
HARDWARE_INTRINSIC(AVX512F, LoadAlignedVector512NonTemporal, 64, 1, {INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_NoFlag)
-HARDWARE_INTRINSIC(AVX512F, StoreAligned, 64, 2, {INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa32, INS_movdqa64, INS_movdqa64, INS_movaps, INS_movapd}, HW_Category_MemoryStore, HW_Flag_NoRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
+HARDWARE_INTRINSIC(AVX512F, LoadVector512, 64, 1, {INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu64, INS_vmovdqu64, INS_movups, INS_movupd}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(AVX512F, Or, 64, 2, {INS_vpord, INS_vpord, INS_vpord, INS_vpord, INS_vpord, INS_vpord, INS_vporq, INS_vporq, INS_orps, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
+HARDWARE_INTRINSIC(AVX512F, Store, 64, 2, {INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu32, INS_vmovdqu64, INS_vmovdqu64, INS_movups, INS_movupd}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_BaseTypeFromSecondArg|HW_Flag_NoCodeGen)
+HARDWARE_INTRINSIC(AVX512F, StoreAligned, 64, 2, {INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa32, INS_vmovdqa64, INS_vmovdqa64, INS_movaps, INS_movapd}, HW_Category_MemoryStore, HW_Flag_NoRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AVX512F, StoreAlignedNonTemporal, 64, 2, {INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntps, INS_movntpd}, HW_Category_MemoryStore, HW_Flag_NoRMWSemantics|HW_Flag_BaseTypeFromSecondArg)
-
+HARDWARE_INTRINSIC(AVX512F, Xor, 64, 2, {INS_vpxord, INS_vpxord, INS_vpxord, INS_vpxord, INS_vpxord, INS_vpxord, INS_vpxorq, INS_vpxorq, INS_xorps, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative)
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// ISA Function name SIMD size NumArg Instructions Category Flags
// AVXVNNI Intrinsics
HARDWARE_INTRINSIC(AVXVNNI, MultiplyWideningAndAdd, -1, 3, {INS_invalid, INS_vpdpbusd, INS_vpdpwssd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFloatingPointUsed|HW_Flag_BaseTypeFromSecondArg)
HARDWARE_INTRINSIC(AVXVNNI, MultiplyWideningAndAddSaturate, -1, 3, {INS_invalid, INS_vpdpbusds, INS_vpdpwssds, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFloatingPointUsed|HW_Flag_BaseTypeFromSecondArg)
+
// ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
// ISA Function name SIMD size NumArg Instructions Category Flags
// {TYP_BYTE, TYP_UBYTE, TYP_SHORT, TYP_USHORT, TYP_INT, TYP_UINT, TYP_LONG, TYP_ULONG, TYP_FLOAT, TYP_DOUBLE}
return InstructionSet_AVX_X64;
case InstructionSet_AVX2:
return InstructionSet_AVX2_X64;
+ case InstructionSet_AVX512BW:
+ return InstructionSet_AVX512BW_X64;
+ case InstructionSet_AVX512BW_VL:
+ return InstructionSet_AVX512BW_VL_X64;
+ case InstructionSet_AVX512CD:
+ return InstructionSet_AVX512CD_X64;
+ case InstructionSet_AVX512CD_VL:
+ return InstructionSet_AVX512CD_VL_X64;
+ case InstructionSet_AVX512DQ:
+ return InstructionSet_AVX512DQ_X64;
+ case InstructionSet_AVX512DQ_VL:
+ return InstructionSet_AVX512DQ_VL_X64;
+ case InstructionSet_AVX512F:
+ return InstructionSet_AVX512F_X64;
+ case InstructionSet_AVX512F_VL:
+ return InstructionSet_AVX512F_VL_X64;
case InstructionSet_AVXVNNI:
return InstructionSet_AVXVNNI_X64;
case InstructionSet_AES:
}
}
+//------------------------------------------------------------------------
+// VLVersionOfIsa: Gets the corresponding AVX512VL only InstructionSet for a given InstructionSet
+//
+// Arguments:
+// isa -- The InstructionSet ID
+//
+// Return Value:
+// The AVX512VL only InstructionSet associated with isa
+static CORINFO_InstructionSet VLVersionOfIsa(CORINFO_InstructionSet isa)
+{
+ switch (isa)
+ {
+ case InstructionSet_AVX512BW:
+ return InstructionSet_AVX512BW_VL;
+ case InstructionSet_AVX512CD:
+ return InstructionSet_AVX512CD_VL;
+ case InstructionSet_AVX512DQ:
+ return InstructionSet_AVX512DQ_VL;
+ case InstructionSet_AVX512F:
+ return InstructionSet_AVX512F_VL;
+ default:
+ return InstructionSet_NONE;
+ }
+}
+
//------------------------------------------------------------------------
// lookupInstructionSet: Gets the InstructionSet for a given class name
//
{
return InstructionSet_AVX2;
}
+ if (strcmp(className, "Avx512BW") == 0)
+ {
+ return InstructionSet_AVX512BW;
+ }
+ if (strcmp(className, "Avx512CD") == 0)
+ {
+ return InstructionSet_AVX512CD;
+ }
+ if (strcmp(className, "Avx512DQ") == 0)
+ {
+ return InstructionSet_AVX512DQ;
+ }
+ if (strcmp(className, "Avx512F") == 0)
+ {
+ return InstructionSet_AVX512F;
+ }
if (strcmp(className, "AvxVnni") == 0)
{
return InstructionSet_AVXVNNI;
{
return InstructionSet_Vector512;
}
+ else if (strcmp(className, "VL") == 0)
+ {
+ assert(!"VL.X64 support doesn't exist in the managed libraries and so is not yet implemented");
+ return InstructionSet_ILLEGAL;
+ }
}
else if (strcmp(className, "Fma") == 0)
{
assert(enclosingClassName != nullptr);
return X64VersionOfIsa(lookupInstructionSet(enclosingClassName));
}
+ else if (strcmp(className, "VL") == 0)
+ {
+ assert(enclosingClassName != nullptr);
+ return VLVersionOfIsa(lookupInstructionSet(enclosingClassName));
+ }
else
{
return lookupInstructionSet(className);
case NI_Vector128_AndNot:
case NI_Vector256_AndNot:
+ case NI_Vector512_AndNot:
{
assert(sig->numArgs == 2);
case NI_Vector128_BitwiseAnd:
case NI_Vector256_BitwiseAnd:
+ case NI_Vector512_BitwiseAnd:
case NI_Vector128_op_BitwiseAnd:
case NI_Vector256_op_BitwiseAnd:
+ case NI_Vector512_op_BitwiseAnd:
{
assert(sig->numArgs == 2);
case NI_Vector128_BitwiseOr:
case NI_Vector256_BitwiseOr:
+ case NI_Vector512_BitwiseOr:
case NI_Vector128_op_BitwiseOr:
case NI_Vector256_op_BitwiseOr:
+ case NI_Vector512_op_BitwiseOr:
{
assert(sig->numArgs == 2);
case NI_SSE_LoadVector128:
case NI_SSE2_LoadVector128:
case NI_AVX_LoadVector256:
+ case NI_AVX512F_LoadVector512:
case NI_Vector128_Load:
case NI_Vector256_Load:
case NI_Vector512_Load:
case NI_Vector128_OnesComplement:
case NI_Vector256_OnesComplement:
+ case NI_Vector512_OnesComplement:
case NI_Vector128_op_OnesComplement:
case NI_Vector256_op_OnesComplement:
+ case NI_Vector512_op_OnesComplement:
{
assert(sig->numArgs == 1);
op1 = impSIMDPopStack(retType);
case NI_SSE_Store:
case NI_SSE2_Store:
case NI_AVX_Store:
+ case NI_AVX512F_Store:
{
assert(retType == TYP_VOID);
assert(sig->numArgs == 2);
case NI_Vector128_Xor:
case NI_Vector256_Xor:
+ case NI_Vector512_Xor:
case NI_Vector128_op_ExclusiveOr:
case NI_Vector256_op_ExclusiveOr:
+ case NI_Vector512_op_ExclusiveOr:
{
assert(sig->numArgs == 2);
Input_64Bit = 1ULL << 32,
Input_Mask = (0xFULL) << 29,
+ // encoding of the REX.W-bit
+ REX_W0 = 1ULL << 33,
+ REX_W1 = 1ULL << 34,
+ REX_WX = 1ULL << 35,
+ REX_WIG = REX_W0,
+
// TODO-Cleanup: Remove this flag and its usage from TARGET_XARCH
INS_FLAGS_DONT_CARE = 0x00ULL,
};
INST3(pmulhuw, "pmulhuw", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xE4), INS_TT_FULL_MEM, Input_16Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Multiply high the packed 16-bit unsigned integers
INST3(pmuludq, "pmuludq", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xF4), INS_TT_FULL_MEM, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // packed multiply 32-bit unsigned integers and store 64-bit result
INST3(pmullw, "pmullw", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xD5), INS_TT_FULL_MEM, Input_16Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed multiply 16 bit unsigned integers and store lower 16 bits of each result
-// TODO-XArch-AVX512: pand, pandn, por, and pxor have AVX512 instructions under different names, pandd, pandq etc
-INST3(pand, "pand", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDB), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND of two xmm regs // TODO-XARCH-AVX512 TT and IP encoded is pand32
-INST3(pandn, "pandn", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDF), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND NOT of two xmm regs // TODO-XARCH-AVX512 TT and IP encoded is pand32
-INST3(por, "por", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEB), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise OR of two xmm regs // TODO-XARCH-AVX512 TT and IP encoded is pand32
+INST3(pand, "pand", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDB), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND of two xmm regs
+INST3(pandn, "pandn", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDF), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND NOT of two xmm regs
+INST3(por, "por", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEB), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise OR of two xmm regs
INST3(pxor, "pxor", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEF), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise XOR of two xmm regs
INST3(psadbw, "psadbw", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xF6), INS_TT_FULL_MEM, Input_8Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Compute the sum of absolute differences of packed unsigned 8-bit integers
INST3(psubsb, "psubsb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xE8), INS_TT_FULL_MEM, Input_8Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Subtract packed 8-bit integers in b from packed 8-bit integers in a using saturation
INST3(FIRST_AVX512_INSTRUCTION, "FIRST_AVX512_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_TT_NONE, INS_FLAGS_None)
INST3(FIRST_AVX512F_INSTRUCTION, "FIRST_AVX512F_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_TT_NONE, INS_FLAGS_None)
-INST3(movdqa32, "movdqa32", IUM_WR, PCKDBL(0x7F), BAD_CODE, PCKDBL(0x6F), INS_TT_FULL_MEM, Input_32Bit | INS_FLAGS_None)
-INST3(movdqa64, "movdqa64", IUM_WR, PCKDBL(0x7F), BAD_CODE, PCKDBL(0x6F), INS_TT_FULL_MEM, Input_64Bit | INS_FLAGS_None)
-INST3(movdqu32, "movdqu32", IUM_WR, SSEFLT(0x7F), BAD_CODE, SSEFLT(0x6F), INS_TT_FULL_MEM, Input_32Bit | INS_FLAGS_None)
-INST3(movdqu64, "movdqu64", IUM_WR, SSEFLT(0x7F), BAD_CODE, SSEFLT(0x6F), INS_TT_FULL_MEM, Input_64Bit | INS_FLAGS_None)
-INST3(vinsertf64x4, "insertf64x4", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x1A), INS_TT_TUPLE4, Input_64Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Insert 256-bit packed double-precision floating point values
-INST3(vinserti64x4, "inserti64x4", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x3A), INS_TT_TUPLE4, Input_64Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Insert 256-bit packed quadword integer values
-INST3(vpternlogd, "pternlogd", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x25), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction)
+INST3(vinsertf64x4, "insertf64x4", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x1A), INS_TT_TUPLE4, Input_64Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Insert 256-bit packed double-precision floating point values
+INST3(vinserti64x4, "inserti64x4", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x3A), INS_TT_TUPLE4, Input_64Bit | INS_Flags_IsDstDstSrcAVXInstruction) // Insert 256-bit packed quadword integer values
+INST3(vmovdqa32, "movdqa32", IUM_WR, PCKDBL(0x7F), BAD_CODE, PCKDBL(0x6F), INS_TT_FULL_MEM, Input_32Bit | REX_W0)
+INST3(vmovdqa64, "movdqa64", IUM_WR, PCKDBL(0x7F), BAD_CODE, PCKDBL(0x6F), INS_TT_FULL_MEM, Input_64Bit | REX_W1)
+INST3(vmovdqu32, "movdqu32", IUM_WR, SSEFLT(0x7F), BAD_CODE, SSEFLT(0x6F), INS_TT_FULL_MEM, Input_32Bit | REX_W0)
+INST3(vmovdqu64, "movdqu64", IUM_WR, SSEFLT(0x7F), BAD_CODE, SSEFLT(0x6F), INS_TT_FULL_MEM, Input_64Bit | REX_W1)
+INST3(vpandd, "pandd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDB), INS_TT_FULL, Input_32Bit | REX_W0 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND of two xmm regs
+INST3(vpandq, "pandq", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDB), INS_TT_FULL, Input_64Bit | REX_W1 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND of two xmm regs
+INST3(vpandnd, "pandnd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDF), INS_TT_FULL, Input_32Bit | REX_W0 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND NOT of two xmm regs
+INST3(vpandnq, "pandnq", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xDF), INS_TT_FULL, Input_64Bit | REX_W1 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise AND NOT of two xmm regs
+INST3(vpord, "pord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEB), INS_TT_FULL, Input_32Bit | REX_W0 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise OR of two xmm regs
+INST3(vporq, "porq", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEB), INS_TT_FULL, Input_64Bit | REX_W1 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise OR of two xmm regs
+INST3(vpternlogd, "pternlogd", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x25), INS_TT_FULL, Input_32Bit | INS_Flags_IsDstDstSrcAVXInstruction)
+INST3(vpxord, "pxord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEF), INS_TT_FULL, Input_32Bit | REX_W0 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise XOR of two xmm regs
+INST3(vpxorq, "pxorq", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0xEF), INS_TT_FULL, Input_64Bit | REX_W1 | INS_Flags_IsDstDstSrcAVXInstruction) // Packed bit-wise XOR of two xmm regs
INST3(LAST_AVX512F_INSTRUCTION, "LAST_AVX512F_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_TT_NONE, INS_FLAGS_None)
INST3(FIRST_AVX512BW_INSTRUCTION, "FIRST_AVX512BW_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_TT_NONE, INS_FLAGS_None)
INST2(rcl, "rcl", IUM_RW, 0x0010D2, BAD_CODE, INS_TT_NONE, Undefined_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
INST2(rcl_1, "rcl", IUM_RW, 0x0010D0, 0x0010D0, INS_TT_NONE, Writes_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
-INST2(rcl_N, "rcl", IUM_RW, 0x0010C0, 0x0010C0, INS_TT_NONE, Undefined_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
+INST2(rcl_N, "rcl", IUM_RW, 0x0010C0, 0x0010C0, INS_TT_NONE, Undefined_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
INST2(rcr, "rcr", IUM_RW, 0x0018D2, BAD_CODE, INS_TT_NONE, Undefined_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
-INST2(rcr_1, "rcr", IUM_RW, 0x0018D0, 0x0018D0, INS_TT_NONE, Writes_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
+INST2(rcr_1, "rcr", IUM_RW, 0x0018D0, 0x0018D0, INS_TT_NONE, Writes_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
INST2(rcr_N, "rcr", IUM_RW, 0x0018C0, 0x0018C0, INS_TT_NONE, Undefined_OF | Writes_CF | Reads_CF | INS_FLAGS_Has_Wbit )
INST2(shl, "shl", IUM_RW, 0x0020D2, BAD_CODE, INS_TT_NONE, Undefined_OF | Writes_SF | Writes_ZF | Undefined_AF | Writes_PF | Writes_CF | INS_FLAGS_Has_Wbit )
INST2(shl_1, "shl", IUM_RW, 0x0020D0, 0x0020D0, INS_TT_NONE, Writes_OF | Writes_SF | Writes_ZF | Undefined_AF | Writes_PF | Writes_CF | INS_FLAGS_Has_Wbit )
public static new bool IsSupported { [Intrinsic] get { return false; } }
}
+
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> And(Vector512<sbyte> left, Vector512<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> And(Vector512<byte> left, Vector512<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> And(Vector512<short> left, Vector512<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> And(Vector512<ushort> left, Vector512<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> And(Vector512<int> left, Vector512<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> And(Vector512<uint> left, Vector512<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> And(Vector512<long> left, Vector512<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> And(Vector512<ulong> left, Vector512<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512 _mm512_and_ps (__m512 a, __m512 b)
+ /// VANDPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> And(Vector512<float> left, Vector512<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_and_pd (__m512d a, __m512d b)
+ /// VANDPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> And(Vector512<double> left, Vector512<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> AndNot(Vector512<sbyte> left, Vector512<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> AndNot(Vector512<byte> left, Vector512<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> AndNot(Vector512<short> left, Vector512<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> AndNot(Vector512<ushort> left, Vector512<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> AndNot(Vector512<int> left, Vector512<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> AndNot(Vector512<uint> left, Vector512<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> AndNot(Vector512<long> left, Vector512<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> AndNot(Vector512<ulong> left, Vector512<ulong> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512 _mm512_andnot_ps (__m512 a, __m512 b)
+ /// VANDNPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_andnot_pd (__m512d a, __m512d b)
+ /// VANDNPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<sbyte> LoadVector512(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<byte> LoadVector512(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<short> LoadVector512(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ushort> LoadVector512(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<int> LoadVector512(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<uint> LoadVector512(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<long> LoadVector512(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ulong> LoadVector512(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512 _mm512_loadu_ps (float const * mem_addr)
+ /// VMOVUPS zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<float> LoadVector512(float* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_loadu_pd (double const * mem_addr)
+ /// VMOVUPD zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<double> LoadVector512(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<sbyte> LoadAlignedVector512(sbyte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<byte> LoadAlignedVector512(byte* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<short> LoadAlignedVector512(short* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ushort> LoadAlignedVector512(ushort* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<int> LoadAlignedVector512(int* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<uint> LoadAlignedVector512(uint* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<long> LoadAlignedVector512(long* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ulong> LoadAlignedVector512(ulong* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512 _mm512_load_ps (float const * mem_addr)
+ /// VMOVAPS zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<float> LoadAlignedVector512(float* address) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_load_pd (double const * mem_addr)
+ /// VMOVAPD zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<double> LoadAlignedVector512(double* address) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m512 _mm512_or_ps (__m512 a, __m512 b)
+ /// VORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> Or(Vector512<float> left, Vector512<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_or_pd (__m512d a, __m512d b)
+ /// VORPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> Or(Vector512<double> left, Vector512<double> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> Or(Vector512<sbyte> left, Vector512<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> Or(Vector512<byte> left, Vector512<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> Or(Vector512<short> left, Vector512<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> Or(Vector512<ushort> left, Vector512<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> Or(Vector512<int> left, Vector512<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> Or(Vector512<uint> left, Vector512<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> Or(Vector512<long> left, Vector512<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> Or(Vector512<ulong> left, Vector512<ulong> right) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(sbyte* address, Vector512<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(byte* address, Vector512<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(short* address, Vector512<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(ushort* address, Vector512<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(int* address, Vector512<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(uint* address, Vector512<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU64 m512, zmm
+ /// </summary>
+ public static unsafe void Store(long* address, Vector512<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU64 m512, zmm
+ /// </summary>
+ public static unsafe void Store(ulong* address, Vector512<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_ps (float * mem_addr, __m512 a)
+ /// VMOVUPS m512, zmm
+ /// </summary>
+ public static unsafe void Store(float* address, Vector512<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_storeu_pd (double * mem_addr, __m512d a)
+ /// VMOVUPD m512, zmm
+ /// </summary>
+ public static unsafe void Store(double* address, Vector512<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(sbyte* address, Vector512<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(byte* address, Vector512<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(short* address, Vector512<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(ushort* address, Vector512<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(int* address, Vector512<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(uint* address, Vector512<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA64 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(long* address, Vector512<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA64 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(ulong* address, Vector512<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_ps (float * mem_addr, __m512 a)
+ /// VMOVAPS m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(float* address, Vector512<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_store_pd (double * mem_addr, __m512d a)
+ /// VMOVAPD m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(double* address, Vector512<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector512<sbyte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector512<byte> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector512<short> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector512<ushort> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector512<int> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector512<uint> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector512<long> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector512<ulong> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_ps (float * mem_addr, __m512 a)
+ /// MOVNTPS m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector512<float> source) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// void _mm512_stream_pd (double * mem_addr, __m512d a)
+ /// MOVNTPD m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector512<double> source) { throw new PlatformNotSupportedException(); }
+
+ /// <summary>
+ /// __m512 _mm512_xor_ps (__m512 a, __m512 b)
+ /// VXORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512d _mm512_xor_pd (__m512d a, __m512d b)
+ /// VXORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> Xor(Vector512<sbyte> left, Vector512<sbyte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> Xor(Vector512<byte> left, Vector512<byte> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> Xor(Vector512<short> left, Vector512<short> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> Xor(Vector512<ushort> left, Vector512<ushort> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> Xor(Vector512<int> left, Vector512<int> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> Xor(Vector512<uint> left, Vector512<uint> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> Xor(Vector512<long> left, Vector512<long> right) { throw new PlatformNotSupportedException(); }
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> Xor(Vector512<ulong> left, Vector512<ulong> right) { throw new PlatformNotSupportedException(); }
}
}
public static new bool IsSupported { get => IsSupported; }
}
+
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> And(Vector512<sbyte> left, Vector512<sbyte> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> And(Vector512<byte> left, Vector512<byte> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> And(Vector512<short> left, Vector512<short> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> And(Vector512<ushort> left, Vector512<ushort> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> And(Vector512<int> left, Vector512<int> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> And(Vector512<uint> left, Vector512<uint> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> And(Vector512<long> left, Vector512<long> right) => And(left, right);
+ /// <summary>
+ /// __m512i _mm512_and_si512 (__m512i a, __m512i b)
+ /// VPAND zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> And(Vector512<ulong> left, Vector512<ulong> right) => And(left, right);
+ /// <summary>
+ /// __m512 _mm512_and_ps (__m512 a, __m512 b)
+ /// VANDPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> And(Vector512<float> left, Vector512<float> right) => And(left, right);
+ /// <summary>
+ /// __m512d _mm512_and_pd (__m512d a, __m512d b)
+ /// VANDPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> And(Vector512<double> left, Vector512<double> right) => And(left, right);
+
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> AndNot(Vector512<sbyte> left, Vector512<sbyte> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> AndNot(Vector512<byte> left, Vector512<byte> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> AndNot(Vector512<short> left, Vector512<short> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> AndNot(Vector512<ushort> left, Vector512<ushort> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> AndNot(Vector512<int> left, Vector512<int> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> AndNot(Vector512<uint> left, Vector512<uint> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> AndNot(Vector512<long> left, Vector512<long> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b)
+ /// VPANDN zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> AndNot(Vector512<ulong> left, Vector512<ulong> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512 _mm512_andnot_ps (__m512 a, __m512 b)
+ /// VANDNPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right) => AndNot(left, right);
+ /// <summary>
+ /// __m512d _mm512_andnot_pd (__m512d a, __m512d b)
+ /// VANDNPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right) => AndNot(left, right);
+
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<sbyte> LoadVector512(sbyte* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<byte> LoadVector512(byte* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<short> LoadVector512(short* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ushort> LoadVector512(ushort* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<int> LoadVector512(int* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<uint> LoadVector512(uint* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<long> LoadVector512(long* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr)
+ /// VMOVDQU64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ulong> LoadVector512(ulong* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512 _mm512_loadu_ps (float const * mem_addr)
+ /// VMOVUPS zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<float> LoadVector512(float* address) => LoadVector512(address);
+ /// <summary>
+ /// __m512d _mm512_loadu_pd (double const * mem_addr)
+ /// VMOVUPD zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<double> LoadVector512(double* address) => LoadVector512(address);
+
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<sbyte> LoadAlignedVector512(sbyte* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<byte> LoadAlignedVector512(byte* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<short> LoadAlignedVector512(short* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ushort> LoadAlignedVector512(ushort* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<int> LoadAlignedVector512(int* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA32 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<uint> LoadAlignedVector512(uint* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<long> LoadAlignedVector512(long* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512i _mm512_load_si512 (__m512i const * mem_addr)
+ /// VMOVDQA64 zmm, m512
+ /// </summary>
+ public static unsafe Vector512<ulong> LoadAlignedVector512(ulong* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512 _mm512_load_ps (float const * mem_addr)
+ /// VMOVAPS zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<float> LoadAlignedVector512(float* address) => LoadAlignedVector512(address);
+ /// <summary>
+ /// __m512d _mm512_load_pd (double const * mem_addr)
+ /// VMOVAPD zmm, zmm/m512
+ /// </summary>
+ public static unsafe Vector512<double> LoadAlignedVector512(double* address) => LoadAlignedVector512(address);
+
+ /// <summary>
+ /// __m512 _mm512_or_ps (__m512 a, __m512 b)
+ /// VORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> Or(Vector512<float> left, Vector512<float> right) => Or(left, right);
+ /// <summary>
+ /// __m512d _mm512_or_pd (__m512d a, __m512d b)
+ /// VORPD zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> Or(Vector512<double> left, Vector512<double> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> Or(Vector512<sbyte> left, Vector512<sbyte> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> Or(Vector512<byte> left, Vector512<byte> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> Or(Vector512<short> left, Vector512<short> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> Or(Vector512<ushort> left, Vector512<ushort> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> Or(Vector512<int> left, Vector512<int> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> Or(Vector512<uint> left, Vector512<uint> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> Or(Vector512<long> left, Vector512<long> right) => Or(left, right);
+ /// <summary>
+ /// __m512i _mm512_or_si512 (__m512i a, __m512i b)
+ /// VPOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> Or(Vector512<ulong> left, Vector512<ulong> right) => Or(left, right);
+
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(sbyte* address, Vector512<sbyte> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(byte* address, Vector512<byte> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(short* address, Vector512<short> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(ushort* address, Vector512<ushort> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(int* address, Vector512<int> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU32 m512, zmm
+ /// </summary>
+ public static unsafe void Store(uint* address, Vector512<uint> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU64 m512, zmm
+ /// </summary>
+ public static unsafe void Store(long* address, Vector512<long> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQU64 m512, zmm
+ /// </summary>
+ public static unsafe void Store(ulong* address, Vector512<ulong> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_ps (float * mem_addr, __m512 a)
+ /// VMOVUPS m512, zmm
+ /// </summary>
+ public static unsafe void Store(float* address, Vector512<float> source) => Store(address, source);
+ /// <summary>
+ /// void _mm512_storeu_pd (double * mem_addr, __m512d a)
+ /// VMOVUPD m512, zmm
+ /// </summary>
+ public static unsafe void Store(double* address, Vector512<double> source) => Store(address, source);
+
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(sbyte* address, Vector512<sbyte> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(byte* address, Vector512<byte> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(short* address, Vector512<short> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(ushort* address, Vector512<ushort> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(int* address, Vector512<int> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA32 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(uint* address, Vector512<uint> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA64 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(long* address, Vector512<long> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVDQA64 m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(ulong* address, Vector512<ulong> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_ps (float * mem_addr, __m512 a)
+ /// VMOVAPS m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(float* address, Vector512<float> source) => StoreAligned(address, source);
+ /// <summary>
+ /// void _mm512_store_pd (double * mem_addr, __m512d a)
+ /// VMOVAPD m512, zmm
+ /// </summary>
+ public static unsafe void StoreAligned(double* address, Vector512<double> source) => StoreAligned(address, source);
+
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector512<sbyte> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(byte* address, Vector512<byte> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(short* address, Vector512<short> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector512<ushort> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(int* address, Vector512<int> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(uint* address, Vector512<uint> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(long* address, Vector512<long> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a)
+ /// VMOVNTDQ m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector512<ulong> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_ps (float * mem_addr, __m512 a)
+ /// MOVNTPS m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(float* address, Vector512<float> source) => StoreAlignedNonTemporal(address, source);
+ /// <summary>
+ /// void _mm512_stream_pd (double * mem_addr, __m512d a)
+ /// MOVNTPD m512, zmm
+ /// </summary>
+ public static unsafe void StoreAlignedNonTemporal(double* address, Vector512<double> source) => StoreAlignedNonTemporal(address, source);
+
+ /// <summary>
+ /// __m512 _mm512_xor_ps (__m512 a, __m512 b)
+ /// VXORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right) => Xor(left, right);
+ /// <summary>
+ /// __m512d _mm512_xor_pd (__m512d a, __m512d b)
+ /// VXORPS zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<sbyte> Xor(Vector512<sbyte> left, Vector512<sbyte> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<byte> Xor(Vector512<byte> left, Vector512<byte> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<short> Xor(Vector512<short> left, Vector512<short> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ushort> Xor(Vector512<ushort> left, Vector512<ushort> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<int> Xor(Vector512<int> left, Vector512<int> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<uint> Xor(Vector512<uint> left, Vector512<uint> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<long> Xor(Vector512<long> left, Vector512<long> right) => Xor(left, right);
+ /// <summary>
+ /// __m512i _mm512_xor_si512 (__m512i a, __m512i b)
+ /// VPXOR zmm, zmm, zmm/m512
+ /// </summary>
+ public static Vector512<ulong> Xor(Vector512<ulong> left, Vector512<ulong> right) => Xor(left, right);
}
}
{
internal Avx512F() { }
public static new bool IsSupported { get { throw null; } }
+ public static System.Runtime.Intrinsics.Vector512<byte> And(System.Runtime.Intrinsics.Vector512<byte> left, System.Runtime.Intrinsics.Vector512<byte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<double> And(System.Runtime.Intrinsics.Vector512<double> left, System.Runtime.Intrinsics.Vector512<double> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<short> And(System.Runtime.Intrinsics.Vector512<short> left, System.Runtime.Intrinsics.Vector512<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<int> And(System.Runtime.Intrinsics.Vector512<int> left, System.Runtime.Intrinsics.Vector512<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<long> And(System.Runtime.Intrinsics.Vector512<long> left, System.Runtime.Intrinsics.Vector512<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<sbyte> And(System.Runtime.Intrinsics.Vector512<sbyte> left, System.Runtime.Intrinsics.Vector512<sbyte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<float> And(System.Runtime.Intrinsics.Vector512<float> left, System.Runtime.Intrinsics.Vector512<float> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ushort> And(System.Runtime.Intrinsics.Vector512<ushort> left, System.Runtime.Intrinsics.Vector512<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<uint> And(System.Runtime.Intrinsics.Vector512<uint> left, System.Runtime.Intrinsics.Vector512<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ulong> And(System.Runtime.Intrinsics.Vector512<ulong> left, System.Runtime.Intrinsics.Vector512<ulong> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<byte> AndNot(System.Runtime.Intrinsics.Vector512<byte> left, System.Runtime.Intrinsics.Vector512<byte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<double> AndNot(System.Runtime.Intrinsics.Vector512<double> left, System.Runtime.Intrinsics.Vector512<double> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<short> AndNot(System.Runtime.Intrinsics.Vector512<short> left, System.Runtime.Intrinsics.Vector512<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<int> AndNot(System.Runtime.Intrinsics.Vector512<int> left, System.Runtime.Intrinsics.Vector512<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<long> AndNot(System.Runtime.Intrinsics.Vector512<long> left, System.Runtime.Intrinsics.Vector512<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<sbyte> AndNot(System.Runtime.Intrinsics.Vector512<sbyte> left, System.Runtime.Intrinsics.Vector512<sbyte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<float> AndNot(System.Runtime.Intrinsics.Vector512<float> left, System.Runtime.Intrinsics.Vector512<float> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ushort> AndNot(System.Runtime.Intrinsics.Vector512<ushort> left, System.Runtime.Intrinsics.Vector512<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<uint> AndNot(System.Runtime.Intrinsics.Vector512<uint> left, System.Runtime.Intrinsics.Vector512<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ulong> AndNot(System.Runtime.Intrinsics.Vector512<ulong> left, System.Runtime.Intrinsics.Vector512<ulong> right) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<byte> LoadAlignedVector512(byte* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<double> LoadAlignedVector512(double* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<short> LoadAlignedVector512(short* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<int> LoadAlignedVector512(int* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<long> LoadAlignedVector512(long* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<sbyte> LoadAlignedVector512(sbyte* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<float> LoadAlignedVector512(float* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<ushort> LoadAlignedVector512(ushort* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<uint> LoadAlignedVector512(uint* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<ulong> LoadAlignedVector512(ulong* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<byte> LoadVector512(byte* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<double> LoadVector512(double* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<short> LoadVector512(short* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<int> LoadVector512(int* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<long> LoadVector512(long* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<sbyte> LoadVector512(sbyte* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<float> LoadVector512(float* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<ushort> LoadVector512(ushort* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<uint> LoadVector512(uint* address) { throw null; }
+ public unsafe static System.Runtime.Intrinsics.Vector512<ulong> LoadVector512(ulong* address) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<byte> Or(System.Runtime.Intrinsics.Vector512<byte> left, System.Runtime.Intrinsics.Vector512<byte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<double> Or(System.Runtime.Intrinsics.Vector512<double> left, System.Runtime.Intrinsics.Vector512<double> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<short> Or(System.Runtime.Intrinsics.Vector512<short> left, System.Runtime.Intrinsics.Vector512<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<int> Or(System.Runtime.Intrinsics.Vector512<int> left, System.Runtime.Intrinsics.Vector512<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<long> Or(System.Runtime.Intrinsics.Vector512<long> left, System.Runtime.Intrinsics.Vector512<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<sbyte> Or(System.Runtime.Intrinsics.Vector512<sbyte> left, System.Runtime.Intrinsics.Vector512<sbyte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<float> Or(System.Runtime.Intrinsics.Vector512<float> left, System.Runtime.Intrinsics.Vector512<float> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ushort> Or(System.Runtime.Intrinsics.Vector512<ushort> left, System.Runtime.Intrinsics.Vector512<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<uint> Or(System.Runtime.Intrinsics.Vector512<uint> left, System.Runtime.Intrinsics.Vector512<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ulong> Or(System.Runtime.Intrinsics.Vector512<ulong> left, System.Runtime.Intrinsics.Vector512<ulong> right) { throw null; }
+ public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector512<byte> source) { }
+ public unsafe static void Store(double* address, System.Runtime.Intrinsics.Vector512<double> source) { }
+ public unsafe static void Store(short* address, System.Runtime.Intrinsics.Vector512<short> source) { }
+ public unsafe static void Store(int* address, System.Runtime.Intrinsics.Vector512<int> source) { }
+ public unsafe static void Store(long* address, System.Runtime.Intrinsics.Vector512<long> source) { }
+ public unsafe static void Store(sbyte* address, System.Runtime.Intrinsics.Vector512<sbyte> source) { }
+ public unsafe static void Store(float* address, System.Runtime.Intrinsics.Vector512<float> source) { }
+ public unsafe static void Store(ushort* address, System.Runtime.Intrinsics.Vector512<ushort> source) { }
+ public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector512<uint> source) { }
+ public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector512<ulong> source) { }
+ public unsafe static void StoreAligned(byte* address, System.Runtime.Intrinsics.Vector512<byte> source) { }
+ public unsafe static void StoreAligned(double* address, System.Runtime.Intrinsics.Vector512<double> source) { }
+ public unsafe static void StoreAligned(short* address, System.Runtime.Intrinsics.Vector512<short> source) { }
+ public unsafe static void StoreAligned(int* address, System.Runtime.Intrinsics.Vector512<int> source) { }
+ public unsafe static void StoreAligned(long* address, System.Runtime.Intrinsics.Vector512<long> source) { }
+ public unsafe static void StoreAligned(sbyte* address, System.Runtime.Intrinsics.Vector512<sbyte> source) { }
+ public unsafe static void StoreAligned(float* address, System.Runtime.Intrinsics.Vector512<float> source) { }
+ public unsafe static void StoreAligned(ushort* address, System.Runtime.Intrinsics.Vector512<ushort> source) { }
+ public unsafe static void StoreAligned(uint* address, System.Runtime.Intrinsics.Vector512<uint> source) { }
+ public unsafe static void StoreAligned(ulong* address, System.Runtime.Intrinsics.Vector512<ulong> source) { }
+ public unsafe static void StoreAlignedNonTemporal(byte* address, System.Runtime.Intrinsics.Vector512<byte> source) { }
+ public unsafe static void StoreAlignedNonTemporal(double* address, System.Runtime.Intrinsics.Vector512<double> source) { }
+ public unsafe static void StoreAlignedNonTemporal(short* address, System.Runtime.Intrinsics.Vector512<short> source) { }
+ public unsafe static void StoreAlignedNonTemporal(int* address, System.Runtime.Intrinsics.Vector512<int> source) { }
+ public unsafe static void StoreAlignedNonTemporal(long* address, System.Runtime.Intrinsics.Vector512<long> source) { }
+ public unsafe static void StoreAlignedNonTemporal(sbyte* address, System.Runtime.Intrinsics.Vector512<sbyte> source) { }
+ public unsafe static void StoreAlignedNonTemporal(float* address, System.Runtime.Intrinsics.Vector512<float> source) { }
+ public unsafe static void StoreAlignedNonTemporal(ushort* address, System.Runtime.Intrinsics.Vector512<ushort> source) { }
+ public unsafe static void StoreAlignedNonTemporal(uint* address, System.Runtime.Intrinsics.Vector512<uint> source) { }
+ public unsafe static void StoreAlignedNonTemporal(ulong* address, System.Runtime.Intrinsics.Vector512<ulong> source) { }
+ public static System.Runtime.Intrinsics.Vector512<byte> Xor(System.Runtime.Intrinsics.Vector512<byte> left, System.Runtime.Intrinsics.Vector512<byte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<double> Xor(System.Runtime.Intrinsics.Vector512<double> left, System.Runtime.Intrinsics.Vector512<double> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<short> Xor(System.Runtime.Intrinsics.Vector512<short> left, System.Runtime.Intrinsics.Vector512<short> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<int> Xor(System.Runtime.Intrinsics.Vector512<int> left, System.Runtime.Intrinsics.Vector512<int> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<long> Xor(System.Runtime.Intrinsics.Vector512<long> left, System.Runtime.Intrinsics.Vector512<long> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<sbyte> Xor(System.Runtime.Intrinsics.Vector512<sbyte> left, System.Runtime.Intrinsics.Vector512<sbyte> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<float> Xor(System.Runtime.Intrinsics.Vector512<float> left, System.Runtime.Intrinsics.Vector512<float> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ushort> Xor(System.Runtime.Intrinsics.Vector512<ushort> left, System.Runtime.Intrinsics.Vector512<ushort> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<uint> Xor(System.Runtime.Intrinsics.Vector512<uint> left, System.Runtime.Intrinsics.Vector512<uint> right) { throw null; }
+ public static System.Runtime.Intrinsics.Vector512<ulong> Xor(System.Runtime.Intrinsics.Vector512<ulong> left, System.Runtime.Intrinsics.Vector512<ulong> right) { throw null; }
public abstract partial class VL
{
internal VL() { }
("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx2", ["Method"] = "BroadcastScalarToVector256", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
};
+(string templateFileName, Dictionary<string, string> templateData)[] Avx512FInputs = new []
+{
+
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "(byte)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(byte)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "(short)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(short)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(int)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(int)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "(long)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(long)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "(sbyte)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(sbyte)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "(ushort)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(ushort)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "(uint)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(uint)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "And", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "(ulong)(left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(ulong)(left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "(byte)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(byte)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "((~BitConverter.DoubleToInt64Bits(left[0])) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "((~BitConverter.DoubleToInt64Bits(left[i])) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "(short)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(short)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(int)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(int)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "(long)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(long)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "(sbyte)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(sbyte)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "((~BitConverter.SingleToInt32Bits(left[0])) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "((~BitConverter.SingleToInt32Bits(left[i])) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "(ushort)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(ushort)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "(uint)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(uint)(~left[i] & right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "AndNot", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "(ulong)(~left[0] & right[0]) != result[0]", ["ValidateRemainingResults"] = "(ulong)(~left[i] & right[i]) != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("LoadUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["Method"] = "LoadVector512", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "firstOp[i] != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "(byte)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(byte)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "(short)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(short)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(int)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(int)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "(long)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(long)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "(sbyte)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(sbyte)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "(ushort)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(ushort)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "(uint)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(uint)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Or", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "(ulong)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(ulong)(left[i] | right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "(byte)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(byte)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "(short)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(short)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(int)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(int)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "(long)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(long)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "(sbyte)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(sbyte)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "(ushort)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(ushort)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "(uint)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(uint)(left[i] ^ right[i]) != result[i]"}),
+ ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Xor", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "(ulong)(left[0] ^ right[0]) != result[0]", ["ValidateRemainingResults"] = "(ulong)(left[i] ^ right[i]) != result[i]"}),
+};
+
(string templateFileName, Dictionary<string, string> templateData)[] Fma_Vector128Inputs = new []
{
("SimpleTernOpTest.template", new Dictionary<string, string> { ["Isa"] = "Fma", ["LoadIsa"] = "Sse2", ["Method"] = "MultiplyAdd", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Math.Round(double.FusedMultiplyAdd(firstOp[0], secondOp[0], thirdOp[0]), 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9))", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(Math.Round(double.FusedMultiplyAdd(firstOp[i], secondOp[i], thirdOp[i]), 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9))"}),
ProcessInputs("Avx1_Vector128", Avx1_Vector128Inputs);
ProcessInputs("Avx2", Avx2Inputs);
ProcessInputs("Avx2_Vector128", Avx2_Vector128Inputs);
+ProcessInputs("Avx512F", Avx512FInputs);
ProcessInputs("Fma_Vector128", Fma_Vector128Inputs);
ProcessInputs("Fma_Vector256", Fma_Vector256Inputs);
ProcessInputs("Bmi1", Bmi1Inputs);
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <AssemblyName>X86_Avx512F_handwritten_r</AssemblyName>
+ <BuildAsStandalone>false</BuildAsStandalone>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>Embedded</DebugType>
+ <Optimize />
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="HandwrittenProgram.cs" />
+ <Compile Include="..\Shared\SimpleUnOpTest_DataTable.cs" />
+
+ <Compile Include="LoadAlignedVector512.cs" />
+ <Compile Include="Store.cs" />
+ <Compile Include="StoreAligned.cs" />
+ <Compile Include="StoreAlignedNonTemporal.cs" />
+ </ItemGroup>
+</Project>
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <AssemblyName>X86_Avx512F_handwritten_ro</AssemblyName>
+ <BuildAsStandalone>false</BuildAsStandalone>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>Embedded</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="HandwrittenProgram.cs" />
+ <Compile Include="..\Shared\SimpleUnOpTest_DataTable.cs" />
+
+ <Compile Include="LoadAlignedVector512.cs" />
+ <Compile Include="Store.cs" />
+ <Compile Include="StoreAligned.cs" />
+ <Compile Include="StoreAlignedNonTemporal.cs" />
+ </ItemGroup>
+</Project>
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <AssemblyName>X86_Avx512F_r</AssemblyName>
+ <BuildAsStandalone>false</BuildAsStandalone>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>Embedded</DebugType>
+ <Optimize />
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="Program.Avx512F.cs" />
+ <Compile Include="..\Shared\Program.cs" />
+ </ItemGroup>
+</Project>
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <AssemblyName>X86_Avx512F_ro</AssemblyName>
+ <BuildAsStandalone>false</BuildAsStandalone>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>Embedded</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="Program.Avx512F.cs" />
+ <Compile Include="..\Shared\Program.cs" />
+ </ItemGroup>
+</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
+using Xunit;
+
+namespace IntelHardwareIntrinsicTest._Avx512F
+{
+ public partial class Program
+ {
+ const int Pass = 100;
+ const int Fail = 0;
+
+ static unsafe void* Align(byte* buffer, byte expectedAlignment)
+ {
+ // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
+ // Then subtract that from the expectedAlignment and add it to the original address
+ // to compute the aligned address.
+
+ var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
+ return (void*)(buffer + misalignment);
+ }
+
+ public unsafe struct TestTable<T> : IDisposable where T : struct
+ {
+ public T[] inArray;
+ public T[] outArray;
+
+ public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer();
+ public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer();
+
+ GCHandle inHandle;
+ GCHandle outHandle;
+ public TestTable(T[] a, T[] b)
+ {
+ this.inArray = a;
+ this.outArray = b;
+
+ inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned);
+ outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned);
+ }
+ public bool CheckResult(Func<T[], T[], bool> check)
+ {
+ return check(inArray, outArray);
+ }
+ public bool CheckResult(Func<T, T, bool> check)
+ {
+ for (int i = 0; i < inArray.Length; i++)
+ {
+ if (!check(inArray[i], outArray[i]))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+ public void Dispose()
+ {
+ inHandle.Free();
+ outHandle.Free();
+ }
+ }
+
+ public unsafe struct AlignedTestTable<T> : IDisposable where T : struct
+ {
+ private byte[] inArray;
+ public T[] outArray;
+
+ private GCHandle inHandle;
+ private GCHandle outHandle;
+
+ private byte simdSize;
+
+ public AlignedTestTable(T[] a, T[] b)
+ {
+ this.inArray = new byte[64];
+ this.outArray = b;
+
+ this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned);
+ this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
+
+ this.simdSize = 64;
+
+ Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<T, byte>(ref a[0]), this.simdSize);
+ }
+
+ public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+ public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer();
+
+ public bool CheckResult(Func<T, T, bool> check)
+ {
+ for (int i = 0; i < outArray.Length; i++)
+ {
+ if (!check(Unsafe.Add<T>(ref Unsafe.AsRef<T>(inArrayPtr), i), outArray[i]))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public void Dispose()
+ {
+ inHandle.Free();
+ outHandle.Free();
+ }
+
+ private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+ {
+ // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
+ // Then subtract that from the expectedAlignment and add it to the original address
+ // to compute the aligned address.
+
+ var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
+ return (void*)(buffer + misalignment);
+ }
+ }
+
+ public unsafe struct TestTable_2Input<T> : IDisposable where T : struct
+ {
+ public T[] inArray1;
+ public T[] inArray2;
+ public T[] outArray;
+
+ public void* inArray1Ptr => inHandle1.AddrOfPinnedObject().ToPointer();
+ public void* inArray2Ptr => inHandle2.AddrOfPinnedObject().ToPointer();
+ public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer();
+
+ GCHandle inHandle1;
+ GCHandle inHandle2;
+ GCHandle outHandle;
+ public TestTable_2Input(T[] a, T[] b, T[] c)
+ {
+ this.inArray1 = a;
+ this.inArray2 = b;
+ this.outArray = c;
+
+ inHandle1 = GCHandle.Alloc(inArray1, GCHandleType.Pinned);
+ inHandle2 = GCHandle.Alloc(inArray2, GCHandleType.Pinned);
+ outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned);
+ }
+ public bool CheckResult(Func<T[], T[], T[], bool> check)
+ {
+ return check(inArray1, inArray2, outArray);
+ }
+ public bool CheckResult(Func<T, T, T, bool> check)
+ {
+ for (int i = 0; i < inArray1.Length; i++)
+ {
+ if (!check(inArray1[i], inArray2[i], outArray[i]))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public void Dispose()
+ {
+ inHandle1.Free();
+ inHandle2.Free();
+ outHandle.Free();
+ }
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
+using Xunit;
+
+namespace IntelHardwareIntrinsicTest._Avx512F
+{
+ public partial class Program
+ {
+ [Fact]
+ public static unsafe void LoadAlignedVector512()
+ {
+ int testResult = Pass;
+
+ if (Avx512F.IsSupported)
+ {
+ {
+ byte* inBuffer = stackalloc byte[128];
+ float* inArray = (float*)Align(inBuffer, 64);
+ float* outArray = stackalloc float[16];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (BitConverter.SingleToInt32Bits(inArray[i]) != BitConverter.SingleToInt32Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on float:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ double* inArray = (double*)Align(inBuffer, 64);
+ double* outArray = stackalloc double[8];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (BitConverter.DoubleToInt64Bits(inArray[i]) != BitConverter.DoubleToInt64Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on double:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ int* inArray = (int*)Align(inBuffer, 64);
+ int* outArray = stackalloc int[16];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on int:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ long* inArray = (long*)Align(inBuffer, 64);
+ long* outArray = stackalloc long[8];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on long:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ uint* inArray = (uint*)Align(inBuffer, 64);
+ uint* outArray = stackalloc uint[16];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on uint:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ ulong* inArray = (ulong*)Align(inBuffer, 64);
+ ulong* outArray = stackalloc ulong[8];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on ulong:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ short* inArray = (short*)Align(inBuffer, 64);
+ short* outArray = stackalloc short[32];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on short:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ ushort* inArray = (ushort*)Align(inBuffer, 64);
+ ushort* outArray = stackalloc ushort[32];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on ushort:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ sbyte* inArray = (sbyte*)Align(inBuffer, 64);
+ sbyte* outArray = stackalloc sbyte[64];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on sbyte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inBuffer = stackalloc byte[128];
+ byte* inArray = (byte*)Align(inBuffer, 64);
+ byte* outArray = stackalloc byte[64];
+ var vf = Avx512F.LoadAlignedVector512(inArray);
+ Unsafe.Write(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F LoadAlignedVector512 failed on byte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+ }
+
+ Assert.Equal(Pass, testResult);
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+
+namespace JIT.HardwareIntrinsics.X86._Avx512F
+{
+ public static partial class Program
+ {
+ static Program()
+ {
+
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
+using Xunit;
+
+namespace IntelHardwareIntrinsicTest._Avx512F
+{
+ public partial class Program
+ {
+ [Fact]
+ public static unsafe void Store()
+ {
+ int testResult = Pass;
+
+ if (Avx512F.IsSupported)
+ {
+ using (TestTable<double> doubleTable = new TestTable<double>(new double[8] { 1, -5, 100, 0, 1, 2, 3, 4 }, new double[8]))
+ {
+ var vf = Unsafe.Read<Vector512<double>>(doubleTable.inArrayPtr);
+ Avx512F.Store((double*)(doubleTable.outArrayPtr), vf);
+
+ if (!doubleTable.CheckResult((x, y) => BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y)))
+ {
+ Console.WriteLine("AVX512F Store failed on double:");
+ foreach (var item in doubleTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<float> floatTable = new TestTable<float>(new float[16] { 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4 }, new float[16]))
+ {
+ var vf = Unsafe.Read<Vector512<float>>(floatTable.inArrayPtr);
+ Avx512F.Store((float*)(floatTable.outArrayPtr), vf);
+
+ if (!floatTable.CheckResult((x, y) => BitConverter.SingleToInt32Bits(x) == BitConverter.SingleToInt32Bits(y)))
+ {
+ Console.WriteLine("AVX512F Store failed on float:");
+ foreach (var item in floatTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<long> intTable = new TestTable<long>(new long[8] { 1, -5, 100, 0, 1, 2, 3, 4 }, new long[8]))
+ {
+ var vf = Unsafe.Read<Vector512<long>>(intTable.inArrayPtr);
+ Avx512F.Store((long*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((long x, long y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on long:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<ulong> intTable = new TestTable<ulong>(new ulong[8] { 1, 5, 100, 0, 1, 2, 3, 4 }, new ulong[8]))
+ {
+ var vf = Unsafe.Read<Vector512<ulong>>(intTable.inArrayPtr);
+ Avx512F.Store((ulong*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((ulong x, ulong y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on ulong:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<int> intTable = new TestTable<int>(new int[16] { 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4 }, new int[16]))
+ {
+ var vf = Unsafe.Read<Vector512<int>>(intTable.inArrayPtr);
+ Avx512F.Store((int*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((int x, int y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on int:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<uint> intTable = new TestTable<uint>(new uint[16] { 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4 }, new uint[16]))
+ {
+ var vf = Unsafe.Read<Vector512<uint>>(intTable.inArrayPtr);
+ Avx512F.Store((uint*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((uint x, uint y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on uint:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<short> intTable = new TestTable<short>(new short[32] { 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4 }, new short[32]))
+ {
+ var vf = Unsafe.Read<Vector512<short>>(intTable.inArrayPtr);
+ Avx512F.Store((short*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((short x, short y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on short:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<ushort> intTable = new TestTable<ushort>(new ushort[32] { 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4 }, new ushort[32]))
+ {
+ var vf = Unsafe.Read<Vector512<ushort>>(intTable.inArrayPtr);
+ Avx512F.Store((ushort*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((ushort x, ushort y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on ushort:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<sbyte> intTable = new TestTable<sbyte>(new sbyte[64] { 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4, 1, -5, 100, 0, 1, 2, 3, 4 }, new sbyte[64]))
+ {
+ var vf = Unsafe.Read<Vector512<sbyte>>(intTable.inArrayPtr);
+ Avx512F.Store((sbyte*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((sbyte x, sbyte y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on sbyte:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ using (TestTable<byte> intTable = new TestTable<byte>(new byte[64] { 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4, 1, 5, 100, 0, 1, 2, 3, 4 }, new byte[64]))
+ {
+ var vf = Unsafe.Read<Vector512<byte>>(intTable.inArrayPtr);
+ Avx512F.Store((byte*)(intTable.outArrayPtr), vf);
+
+ if (!intTable.CheckResult((byte x, byte y) => x == y))
+ {
+ Console.WriteLine("AVX512F Store failed on byte:");
+ foreach (var item in intTable.outArray)
+ {
+ Console.Write(item + ", ");
+ }
+ Console.WriteLine();
+ testResult = Fail;
+ }
+ }
+
+ }
+
+ Assert.Equal(Pass, testResult);
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
+using Xunit;
+
+namespace IntelHardwareIntrinsicTest._Avx512F
+{
+ public partial class Program
+ {
+ [Fact]
+ public static unsafe void StoreAligned()
+ {
+ int testResult = Pass;
+
+ if (Avx512F.IsSupported)
+ {
+ {
+ double* inArray = stackalloc double[8];
+ byte* outBuffer = stackalloc byte[128];
+ double* outArray = (double*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<double>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (BitConverter.DoubleToInt64Bits(inArray[i]) != BitConverter.DoubleToInt64Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on double:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ float* inArray = stackalloc float[16];
+ byte* outBuffer = stackalloc byte[128];
+ float* outArray = (float*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<float>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (BitConverter.SingleToInt32Bits(inArray[i]) != BitConverter.SingleToInt32Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on float:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ long* inArray = stackalloc long[8];
+ byte* outBuffer = stackalloc byte[128];
+ long* outArray = (long*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<long>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on long:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ ulong* inArray = stackalloc ulong[8];
+ byte* outBuffer = stackalloc byte[128];
+ ulong* outArray = (ulong*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<ulong>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on ulong:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ int* inArray = stackalloc int[16];
+ byte* outBuffer = stackalloc byte[128];
+ int* outArray = (int*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<int>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on int:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ uint* inArray = stackalloc uint[16];
+ byte* outBuffer = stackalloc byte[128];
+ uint* outArray = (uint*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<uint>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on uint:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ short* inArray = stackalloc short[32];
+ byte* outBuffer = stackalloc byte[128];
+ short* outArray = (short*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<short>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on short:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ ushort* inArray = stackalloc ushort[32];
+ byte* outBuffer = stackalloc byte[128];
+ ushort* outArray = (ushort*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<ushort>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on ushort:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inArray = stackalloc byte[64];
+ byte* outBuffer = stackalloc byte[128];
+ byte* outArray = (byte*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<byte>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on byte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ sbyte* inArray = stackalloc sbyte[64];
+ byte* outBuffer = stackalloc byte[128];
+ sbyte* outArray = (sbyte*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<sbyte>>(inArray);
+ Avx512F.StoreAligned(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAligned failed on byte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+ }
+
+ Assert.Equal(Pass, testResult);
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
+using Xunit;
+
+namespace IntelHardwareIntrinsicTest._Avx512F
+{
+ public partial class Program
+ {
+ [Fact]
+ public static unsafe void StoreAlignedNonTemporal()
+ {
+ int testResult = Pass;
+
+ if (Avx512F.IsSupported)
+ {
+ {
+ double* inArray = stackalloc double[8];
+ byte* outBuffer = stackalloc byte[128];
+ double* outArray = (double*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<double>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (BitConverter.DoubleToInt64Bits(inArray[i]) != BitConverter.DoubleToInt64Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on double:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ float* inArray = stackalloc float[16];
+ byte* outBuffer = stackalloc byte[128];
+ float* outArray = (float*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<float>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (BitConverter.SingleToInt32Bits(inArray[i]) != BitConverter.SingleToInt32Bits(outArray[i]))
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on float:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ long* inArray = stackalloc long[8];
+ byte* outBuffer = stackalloc byte[128];
+ long* outArray = (long*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<long>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on long:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ ulong* inArray = stackalloc ulong[8];
+ byte* outBuffer = stackalloc byte[128];
+ ulong* outArray = (ulong*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<ulong>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 8; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on ulong:");
+ for (var n = 0; n < 8; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ int* inArray = stackalloc int[16];
+ byte* outBuffer = stackalloc byte[128];
+ int* outArray = (int*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<int>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on int:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ uint* inArray = stackalloc uint[16];
+ byte* outBuffer = stackalloc byte[128];
+ uint* outArray = (uint*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<uint>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 16; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on uint:");
+ for (var n = 0; n < 16; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ short* inArray = stackalloc short[32];
+ byte* outBuffer = stackalloc byte[128];
+ short* outArray = (short*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<short>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on short:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ ushort* inArray = stackalloc ushort[32];
+ byte* outBuffer = stackalloc byte[128];
+ ushort* outArray = (ushort*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<ushort>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 32; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on ushort:");
+ for (var n = 0; n < 32; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ byte* inArray = stackalloc byte[64];
+ byte* outBuffer = stackalloc byte[128];
+ byte* outArray = (byte*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<byte>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on byte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+
+ {
+ sbyte* inArray = stackalloc sbyte[64];
+ byte* outBuffer = stackalloc byte[128];
+ sbyte* outArray = (sbyte*)Align(outBuffer, 64);
+
+ var vf = Unsafe.Read<Vector512<sbyte>>(inArray);
+ Avx512F.StoreAlignedNonTemporal(outArray, vf);
+
+ for (var i = 0; i < 64; i++)
+ {
+ if (inArray[i] != outArray[i])
+ {
+ Console.WriteLine("AVX512F StoreAlignedNonTemporal failed on byte:");
+ for (var n = 0; n < 64; n++)
+ {
+ Console.Write(outArray[n] + ", ");
+ }
+ Console.WriteLine();
+
+ testResult = Fail;
+ break;
+ }
+ }
+ }
+ }
+
+ Assert.Equal(Pass, testResult);
+ }
+ }
+}
public ScalarSimdUnaryOpTest__DataTable(TResult[] outArray, int alignment)
{
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
public SimdScalarUnaryOpTest__DataTable(TOp1[] inArray, int alignment)
{
int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray)
{
throw new ArgumentException("Invalid value of alignment");
}
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
{
int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
-
+
public void RunStructFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
{
throw new ArgumentException("Invalid value of alignment");
}
public DataTable({Op1BaseType}[] inArray1, int alignment)
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1)
{
throw new ArgumentException("Invalid value of alignment");
}
int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op3BaseType}>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
{
int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
- if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
+ if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
{
throw new ArgumentException("Invalid value of alignment");
}
projects / platform / upstream / dotnet / runtime.git / commitdiff