From: Tanner Gooding Date: Fri, 10 Jul 2020 17:58:28 +0000 (-0700) Subject: Add X64/Arm64 nested classes to System.Runtime.Intrinsics where missing (#38460) X-Git-Tag: submit/tizen/20210909.063632~6795 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=f501f7496ae8e79633c02c03fbbe2544f443753e;p=platform%2Fupstream%2Fdotnet%2Fruntime.git Add X64/Arm64 nested classes to System.Runtime.Intrinsics where missing (#38460) * Ensure that Arm64 and X64 classes exist in the appropriate places for the HWIntrinsics * Adding the new Arm64 and X64 instruction sets * Add a new test validating the IsSupported heirarchy is correct * Updating the JIT to support the new Arm64 and X64 instruction sets * Add missing new keywords * Fixing a member name * Adding Runtime_34587 to the mono exclude list --- diff --git a/src/coreclr/src/inc/corinfoinstructionset.h b/src/coreclr/src/inc/corinfoinstructionset.h index 26b3f74..a2d9aaf 100644 --- a/src/coreclr/src/inc/corinfoinstructionset.h +++ b/src/coreclr/src/inc/corinfoinstructionset.h @@ -17,17 +17,20 @@ enum CORINFO_InstructionSet InstructionSet_NONE = 63, #ifdef TARGET_ARM64 InstructionSet_ArmBase=1, - InstructionSet_ArmBase_Arm64=2, - InstructionSet_AdvSimd=3, - InstructionSet_AdvSimd_Arm64=4, - InstructionSet_Aes=5, - InstructionSet_Crc32=6, - InstructionSet_Crc32_Arm64=7, - InstructionSet_Sha1=8, - InstructionSet_Sha256=9, - InstructionSet_Atomics=10, - InstructionSet_Vector64=11, - InstructionSet_Vector128=12, + InstructionSet_AdvSimd=2, + InstructionSet_Aes=3, + InstructionSet_Crc32=4, + InstructionSet_Sha1=5, + InstructionSet_Sha256=6, + InstructionSet_Atomics=7, + InstructionSet_Vector64=8, + InstructionSet_Vector128=9, + InstructionSet_ArmBase_Arm64=10, + InstructionSet_AdvSimd_Arm64=11, + InstructionSet_Aes_Arm64=12, + InstructionSet_Crc32_Arm64=13, + InstructionSet_Sha1_Arm64=14, + InstructionSet_Sha256_Arm64=15, #endif // TARGET_ARM64 #ifdef TARGET_AMD64 InstructionSet_X86Base=1, @@ -49,14 +52,21 @@ enum CORINFO_InstructionSet InstructionSet_Vector128=17, InstructionSet_Vector256=18, InstructionSet_X86Base_X64=19, - InstructionSet_BMI1_X64=20, - InstructionSet_BMI2_X64=21, - InstructionSet_LZCNT_X64=22, - InstructionSet_POPCNT_X64=23, - InstructionSet_SSE_X64=24, - InstructionSet_SSE2_X64=25, - InstructionSet_SSE41_X64=26, - InstructionSet_SSE42_X64=27, + InstructionSet_SSE_X64=20, + InstructionSet_SSE2_X64=21, + InstructionSet_SSE3_X64=22, + InstructionSet_SSSE3_X64=23, + InstructionSet_SSE41_X64=24, + InstructionSet_SSE42_X64=25, + InstructionSet_AVX_X64=26, + InstructionSet_AVX2_X64=27, + InstructionSet_AES_X64=28, + InstructionSet_BMI1_X64=29, + InstructionSet_BMI2_X64=30, + InstructionSet_FMA_X64=31, + InstructionSet_LZCNT_X64=32, + InstructionSet_PCLMULQDQ_X64=33, + InstructionSet_POPCNT_X64=34, #endif // TARGET_AMD64 #ifdef TARGET_X86 InstructionSet_X86Base=1, @@ -78,14 +88,21 @@ enum CORINFO_InstructionSet InstructionSet_Vector128=17, InstructionSet_Vector256=18, InstructionSet_X86Base_X64=19, - InstructionSet_BMI1_X64=20, - InstructionSet_BMI2_X64=21, - InstructionSet_LZCNT_X64=22, - InstructionSet_POPCNT_X64=23, - InstructionSet_SSE_X64=24, - InstructionSet_SSE2_X64=25, - InstructionSet_SSE41_X64=26, - InstructionSet_SSE42_X64=27, + InstructionSet_SSE_X64=20, + InstructionSet_SSE2_X64=21, + InstructionSet_SSE3_X64=22, + InstructionSet_SSSE3_X64=23, + InstructionSet_SSE41_X64=24, + InstructionSet_SSE42_X64=25, + InstructionSet_AVX_X64=26, + InstructionSet_AVX2_X64=27, + InstructionSet_AES_X64=28, + InstructionSet_BMI1_X64=29, + InstructionSet_BMI2_X64=30, + InstructionSet_FMA_X64=31, + InstructionSet_LZCNT_X64=32, + InstructionSet_PCLMULQDQ_X64=33, + InstructionSet_POPCNT_X64=34, #endif // TARGET_X86 }; @@ -137,8 +154,14 @@ public: AddInstructionSet(InstructionSet_ArmBase_Arm64); if (HasInstructionSet(InstructionSet_AdvSimd)) AddInstructionSet(InstructionSet_AdvSimd_Arm64); + if (HasInstructionSet(InstructionSet_Aes)) + AddInstructionSet(InstructionSet_Aes_Arm64); if (HasInstructionSet(InstructionSet_Crc32)) AddInstructionSet(InstructionSet_Crc32_Arm64); + if (HasInstructionSet(InstructionSet_Sha1)) + AddInstructionSet(InstructionSet_Sha1_Arm64); + if (HasInstructionSet(InstructionSet_Sha256)) + AddInstructionSet(InstructionSet_Sha256_Arm64); #endif // TARGET_ARM64 #ifdef TARGET_AMD64 if (HasInstructionSet(InstructionSet_X86Base)) @@ -147,16 +170,30 @@ public: AddInstructionSet(InstructionSet_SSE_X64); if (HasInstructionSet(InstructionSet_SSE2)) AddInstructionSet(InstructionSet_SSE2_X64); + if (HasInstructionSet(InstructionSet_SSE3)) + AddInstructionSet(InstructionSet_SSE3_X64); + if (HasInstructionSet(InstructionSet_SSSE3)) + AddInstructionSet(InstructionSet_SSSE3_X64); if (HasInstructionSet(InstructionSet_SSE41)) AddInstructionSet(InstructionSet_SSE41_X64); if (HasInstructionSet(InstructionSet_SSE42)) AddInstructionSet(InstructionSet_SSE42_X64); + if (HasInstructionSet(InstructionSet_AVX)) + AddInstructionSet(InstructionSet_AVX_X64); + if (HasInstructionSet(InstructionSet_AVX2)) + AddInstructionSet(InstructionSet_AVX2_X64); + if (HasInstructionSet(InstructionSet_AES)) + AddInstructionSet(InstructionSet_AES_X64); if (HasInstructionSet(InstructionSet_BMI1)) AddInstructionSet(InstructionSet_BMI1_X64); if (HasInstructionSet(InstructionSet_BMI2)) AddInstructionSet(InstructionSet_BMI2_X64); + if (HasInstructionSet(InstructionSet_FMA)) + AddInstructionSet(InstructionSet_FMA_X64); if (HasInstructionSet(InstructionSet_LZCNT)) AddInstructionSet(InstructionSet_LZCNT_X64); + if (HasInstructionSet(InstructionSet_PCLMULQDQ)) + AddInstructionSet(InstructionSet_PCLMULQDQ_X64); if (HasInstructionSet(InstructionSet_POPCNT)) AddInstructionSet(InstructionSet_POPCNT_X64); #endif // TARGET_AMD64 @@ -192,10 +229,22 @@ inline CORINFO_InstructionSetFlags EnsureInstructionSetFlagsAreValid(CORINFO_Ins resultflags.RemoveInstructionSet(InstructionSet_AdvSimd); if (resultflags.HasInstructionSet(InstructionSet_AdvSimd_Arm64) && !resultflags.HasInstructionSet(InstructionSet_AdvSimd)) resultflags.RemoveInstructionSet(InstructionSet_AdvSimd_Arm64); + if (resultflags.HasInstructionSet(InstructionSet_Aes) && !resultflags.HasInstructionSet(InstructionSet_Aes_Arm64)) + resultflags.RemoveInstructionSet(InstructionSet_Aes); + if (resultflags.HasInstructionSet(InstructionSet_Aes_Arm64) && !resultflags.HasInstructionSet(InstructionSet_Aes)) + resultflags.RemoveInstructionSet(InstructionSet_Aes_Arm64); if (resultflags.HasInstructionSet(InstructionSet_Crc32) && !resultflags.HasInstructionSet(InstructionSet_Crc32_Arm64)) resultflags.RemoveInstructionSet(InstructionSet_Crc32); if (resultflags.HasInstructionSet(InstructionSet_Crc32_Arm64) && !resultflags.HasInstructionSet(InstructionSet_Crc32)) resultflags.RemoveInstructionSet(InstructionSet_Crc32_Arm64); + if (resultflags.HasInstructionSet(InstructionSet_Sha1) && !resultflags.HasInstructionSet(InstructionSet_Sha1_Arm64)) + resultflags.RemoveInstructionSet(InstructionSet_Sha1); + if (resultflags.HasInstructionSet(InstructionSet_Sha1_Arm64) && !resultflags.HasInstructionSet(InstructionSet_Sha1)) + resultflags.RemoveInstructionSet(InstructionSet_Sha1_Arm64); + if (resultflags.HasInstructionSet(InstructionSet_Sha256) && !resultflags.HasInstructionSet(InstructionSet_Sha256_Arm64)) + resultflags.RemoveInstructionSet(InstructionSet_Sha256); + if (resultflags.HasInstructionSet(InstructionSet_Sha256_Arm64) && !resultflags.HasInstructionSet(InstructionSet_Sha256)) + resultflags.RemoveInstructionSet(InstructionSet_Sha256_Arm64); if (resultflags.HasInstructionSet(InstructionSet_AdvSimd) && !resultflags.HasInstructionSet(InstructionSet_ArmBase)) resultflags.RemoveInstructionSet(InstructionSet_AdvSimd); if (resultflags.HasInstructionSet(InstructionSet_Aes) && !resultflags.HasInstructionSet(InstructionSet_ArmBase)) @@ -220,6 +269,14 @@ inline CORINFO_InstructionSetFlags EnsureInstructionSetFlagsAreValid(CORINFO_Ins resultflags.RemoveInstructionSet(InstructionSet_SSE2); if (resultflags.HasInstructionSet(InstructionSet_SSE2_X64) && !resultflags.HasInstructionSet(InstructionSet_SSE2)) resultflags.RemoveInstructionSet(InstructionSet_SSE2_X64); + if (resultflags.HasInstructionSet(InstructionSet_SSE3) && !resultflags.HasInstructionSet(InstructionSet_SSE3_X64)) + resultflags.RemoveInstructionSet(InstructionSet_SSE3); + if (resultflags.HasInstructionSet(InstructionSet_SSE3_X64) && !resultflags.HasInstructionSet(InstructionSet_SSE3)) + resultflags.RemoveInstructionSet(InstructionSet_SSE3_X64); + if (resultflags.HasInstructionSet(InstructionSet_SSSE3) && !resultflags.HasInstructionSet(InstructionSet_SSSE3_X64)) + resultflags.RemoveInstructionSet(InstructionSet_SSSE3); + if (resultflags.HasInstructionSet(InstructionSet_SSSE3_X64) && !resultflags.HasInstructionSet(InstructionSet_SSSE3)) + resultflags.RemoveInstructionSet(InstructionSet_SSSE3_X64); if (resultflags.HasInstructionSet(InstructionSet_SSE41) && !resultflags.HasInstructionSet(InstructionSet_SSE41_X64)) resultflags.RemoveInstructionSet(InstructionSet_SSE41); if (resultflags.HasInstructionSet(InstructionSet_SSE41_X64) && !resultflags.HasInstructionSet(InstructionSet_SSE41)) @@ -228,6 +285,18 @@ inline CORINFO_InstructionSetFlags EnsureInstructionSetFlagsAreValid(CORINFO_Ins resultflags.RemoveInstructionSet(InstructionSet_SSE42); if (resultflags.HasInstructionSet(InstructionSet_SSE42_X64) && !resultflags.HasInstructionSet(InstructionSet_SSE42)) resultflags.RemoveInstructionSet(InstructionSet_SSE42_X64); + if (resultflags.HasInstructionSet(InstructionSet_AVX) && !resultflags.HasInstructionSet(InstructionSet_AVX_X64)) + resultflags.RemoveInstructionSet(InstructionSet_AVX); + if (resultflags.HasInstructionSet(InstructionSet_AVX_X64) && !resultflags.HasInstructionSet(InstructionSet_AVX)) + resultflags.RemoveInstructionSet(InstructionSet_AVX_X64); + if (resultflags.HasInstructionSet(InstructionSet_AVX2) && !resultflags.HasInstructionSet(InstructionSet_AVX2_X64)) + resultflags.RemoveInstructionSet(InstructionSet_AVX2); + if (resultflags.HasInstructionSet(InstructionSet_AVX2_X64) && !resultflags.HasInstructionSet(InstructionSet_AVX2)) + resultflags.RemoveInstructionSet(InstructionSet_AVX2_X64); + if (resultflags.HasInstructionSet(InstructionSet_AES) && !resultflags.HasInstructionSet(InstructionSet_AES_X64)) + resultflags.RemoveInstructionSet(InstructionSet_AES); + if (resultflags.HasInstructionSet(InstructionSet_AES_X64) && !resultflags.HasInstructionSet(InstructionSet_AES)) + resultflags.RemoveInstructionSet(InstructionSet_AES_X64); if (resultflags.HasInstructionSet(InstructionSet_BMI1) && !resultflags.HasInstructionSet(InstructionSet_BMI1_X64)) resultflags.RemoveInstructionSet(InstructionSet_BMI1); if (resultflags.HasInstructionSet(InstructionSet_BMI1_X64) && !resultflags.HasInstructionSet(InstructionSet_BMI1)) @@ -236,10 +305,18 @@ inline CORINFO_InstructionSetFlags EnsureInstructionSetFlagsAreValid(CORINFO_Ins resultflags.RemoveInstructionSet(InstructionSet_BMI2); if (resultflags.HasInstructionSet(InstructionSet_BMI2_X64) && !resultflags.HasInstructionSet(InstructionSet_BMI2)) resultflags.RemoveInstructionSet(InstructionSet_BMI2_X64); + if (resultflags.HasInstructionSet(InstructionSet_FMA) && !resultflags.HasInstructionSet(InstructionSet_FMA_X64)) + resultflags.RemoveInstructionSet(InstructionSet_FMA); + if (resultflags.HasInstructionSet(InstructionSet_FMA_X64) && !resultflags.HasInstructionSet(InstructionSet_FMA)) + resultflags.RemoveInstructionSet(InstructionSet_FMA_X64); if (resultflags.HasInstructionSet(InstructionSet_LZCNT) && !resultflags.HasInstructionSet(InstructionSet_LZCNT_X64)) resultflags.RemoveInstructionSet(InstructionSet_LZCNT); if (resultflags.HasInstructionSet(InstructionSet_LZCNT_X64) && !resultflags.HasInstructionSet(InstructionSet_LZCNT)) resultflags.RemoveInstructionSet(InstructionSet_LZCNT_X64); + if (resultflags.HasInstructionSet(InstructionSet_PCLMULQDQ) && !resultflags.HasInstructionSet(InstructionSet_PCLMULQDQ_X64)) + resultflags.RemoveInstructionSet(InstructionSet_PCLMULQDQ); + if (resultflags.HasInstructionSet(InstructionSet_PCLMULQDQ_X64) && !resultflags.HasInstructionSet(InstructionSet_PCLMULQDQ)) + resultflags.RemoveInstructionSet(InstructionSet_PCLMULQDQ_X64); if (resultflags.HasInstructionSet(InstructionSet_POPCNT) && !resultflags.HasInstructionSet(InstructionSet_POPCNT_X64)) resultflags.RemoveInstructionSet(InstructionSet_POPCNT); if (resultflags.HasInstructionSet(InstructionSet_POPCNT_X64) && !resultflags.HasInstructionSet(InstructionSet_POPCNT)) @@ -332,14 +409,20 @@ inline const char *InstructionSetToString(CORINFO_InstructionSet instructionSet) return "AdvSimd_Arm64"; case InstructionSet_Aes : return "Aes"; + case InstructionSet_Aes_Arm64 : + return "Aes_Arm64"; case InstructionSet_Crc32 : return "Crc32"; case InstructionSet_Crc32_Arm64 : return "Crc32_Arm64"; case InstructionSet_Sha1 : return "Sha1"; + case InstructionSet_Sha1_Arm64 : + return "Sha1_Arm64"; case InstructionSet_Sha256 : return "Sha256"; + case InstructionSet_Sha256_Arm64 : + return "Sha256_Arm64"; case InstructionSet_Atomics : return "Atomics"; case InstructionSet_Vector64 : @@ -362,8 +445,12 @@ inline const char *InstructionSetToString(CORINFO_InstructionSet instructionSet) return "SSE2_X64"; case InstructionSet_SSE3 : return "SSE3"; + case InstructionSet_SSE3_X64 : + return "SSE3_X64"; case InstructionSet_SSSE3 : return "SSSE3"; + case InstructionSet_SSSE3_X64 : + return "SSSE3_X64"; case InstructionSet_SSE41 : return "SSE41"; case InstructionSet_SSE41_X64 : @@ -374,10 +461,16 @@ inline const char *InstructionSetToString(CORINFO_InstructionSet instructionSet) return "SSE42_X64"; case InstructionSet_AVX : return "AVX"; + case InstructionSet_AVX_X64 : + return "AVX_X64"; case InstructionSet_AVX2 : return "AVX2"; + case InstructionSet_AVX2_X64 : + return "AVX2_X64"; case InstructionSet_AES : return "AES"; + case InstructionSet_AES_X64 : + return "AES_X64"; case InstructionSet_BMI1 : return "BMI1"; case InstructionSet_BMI1_X64 : @@ -388,12 +481,16 @@ inline const char *InstructionSetToString(CORINFO_InstructionSet instructionSet) return "BMI2_X64"; case InstructionSet_FMA : return "FMA"; + case InstructionSet_FMA_X64 : + return "FMA_X64"; case InstructionSet_LZCNT : return "LZCNT"; case InstructionSet_LZCNT_X64 : return "LZCNT_X64"; case InstructionSet_PCLMULQDQ : return "PCLMULQDQ"; + case InstructionSet_PCLMULQDQ_X64 : + return "PCLMULQDQ_X64"; case InstructionSet_POPCNT : return "POPCNT"; case InstructionSet_POPCNT_X64 : diff --git a/src/coreclr/src/jit/hwintrinsicarm64.cpp b/src/coreclr/src/jit/hwintrinsicarm64.cpp index 4b25b49..f869fcd 100644 --- a/src/coreclr/src/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/src/jit/hwintrinsicarm64.cpp @@ -20,10 +20,16 @@ static CORINFO_InstructionSet Arm64VersionOfIsa(CORINFO_InstructionSet isa) { case InstructionSet_AdvSimd: return InstructionSet_AdvSimd_Arm64; + case InstructionSet_Aes: + return InstructionSet_Aes_Arm64; case InstructionSet_ArmBase: return InstructionSet_ArmBase_Arm64; case InstructionSet_Crc32: return InstructionSet_Crc32_Arm64; + case InstructionSet_Sha1: + return InstructionSet_Sha1_Arm64; + case InstructionSet_Sha256: + return InstructionSet_Sha256_Arm64; default: return InstructionSet_NONE; } @@ -129,12 +135,15 @@ bool HWIntrinsicInfo::isFullyImplementedIsa(CORINFO_InstructionSet isa) case InstructionSet_AdvSimd: case InstructionSet_AdvSimd_Arm64: case InstructionSet_Aes: + case InstructionSet_Aes_Arm64: case InstructionSet_ArmBase: case InstructionSet_ArmBase_Arm64: case InstructionSet_Crc32: case InstructionSet_Crc32_Arm64: case InstructionSet_Sha1: + case InstructionSet_Sha1_Arm64: case InstructionSet_Sha256: + case InstructionSet_Sha256_Arm64: case InstructionSet_Vector64: case InstructionSet_Vector128: { diff --git a/src/coreclr/src/jit/hwintrinsicxarch.cpp b/src/coreclr/src/jit/hwintrinsicxarch.cpp index d001076..8d7824e 100644 --- a/src/coreclr/src/jit/hwintrinsicxarch.cpp +++ b/src/coreclr/src/jit/hwintrinsicxarch.cpp @@ -24,16 +24,30 @@ static CORINFO_InstructionSet X64VersionOfIsa(CORINFO_InstructionSet isa) return InstructionSet_SSE_X64; case InstructionSet_SSE2: return InstructionSet_SSE2_X64; + case InstructionSet_SSE3: + return InstructionSet_SSE3_X64; + case InstructionSet_SSSE3: + return InstructionSet_SSSE3_X64; case InstructionSet_SSE41: return InstructionSet_SSE41_X64; case InstructionSet_SSE42: return InstructionSet_SSE42_X64; + case InstructionSet_AVX: + return InstructionSet_AVX_X64; + case InstructionSet_AVX2: + return InstructionSet_AVX2_X64; + case InstructionSet_AES: + return InstructionSet_AES_X64; case InstructionSet_BMI1: return InstructionSet_BMI1_X64; case InstructionSet_BMI2: return InstructionSet_BMI2_X64; + case InstructionSet_FMA: + return InstructionSet_FMA_X64; case InstructionSet_LZCNT: return InstructionSet_LZCNT_X64; + case InstructionSet_PCLMULQDQ: + return InstructionSet_PCLMULQDQ_X64; case InstructionSet_POPCNT: return InstructionSet_POPCNT_X64; default: @@ -329,16 +343,21 @@ bool HWIntrinsicInfo::isFullyImplementedIsa(CORINFO_InstructionSet isa) { // These ISAs are fully implemented case InstructionSet_AES: + case InstructionSet_AES_X64: case InstructionSet_AVX: + case InstructionSet_AVX_X64: case InstructionSet_AVX2: + case InstructionSet_AVX2_X64: case InstructionSet_BMI1: - case InstructionSet_BMI2: case InstructionSet_BMI1_X64: + case InstructionSet_BMI2: case InstructionSet_BMI2_X64: case InstructionSet_FMA: + case InstructionSet_FMA_X64: case InstructionSet_LZCNT: case InstructionSet_LZCNT_X64: case InstructionSet_PCLMULQDQ: + case InstructionSet_PCLMULQDQ_X64: case InstructionSet_POPCNT: case InstructionSet_POPCNT_X64: case InstructionSet_SSE: @@ -346,7 +365,9 @@ bool HWIntrinsicInfo::isFullyImplementedIsa(CORINFO_InstructionSet isa) case InstructionSet_SSE2: case InstructionSet_SSE2_X64: case InstructionSet_SSE3: + case InstructionSet_SSE3_X64: case InstructionSet_SSSE3: + case InstructionSet_SSSE3_X64: case InstructionSet_SSE41: case InstructionSet_SSE41_X64: case InstructionSet_SSE42: @@ -379,8 +400,8 @@ bool HWIntrinsicInfo::isScalarIsa(CORINFO_InstructionSet isa) switch (isa) { case InstructionSet_BMI1: - case InstructionSet_BMI2: case InstructionSet_BMI1_X64: + case InstructionSet_BMI2: case InstructionSet_BMI2_X64: case InstructionSet_LZCNT: case InstructionSet_LZCNT_X64: diff --git a/src/coreclr/src/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs b/src/coreclr/src/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs index 558cd48..76e6e79 100644 --- a/src/coreclr/src/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs +++ b/src/coreclr/src/tools/Common/Internal/Runtime/ReadyToRunInstructionSetHelper.cs @@ -28,10 +28,13 @@ namespace Internal.ReadyToRunConstants case InstructionSet.ARM64_AdvSimd: return ReadyToRunInstructionSet.AdvSimd; case InstructionSet.ARM64_AdvSimd_Arm64: return ReadyToRunInstructionSet.AdvSimd; case InstructionSet.ARM64_Aes: return ReadyToRunInstructionSet.Aes; + case InstructionSet.ARM64_Aes_Arm64: return ReadyToRunInstructionSet.Aes; case InstructionSet.ARM64_Crc32: return ReadyToRunInstructionSet.Crc32; case InstructionSet.ARM64_Crc32_Arm64: return ReadyToRunInstructionSet.Crc32; case InstructionSet.ARM64_Sha1: return ReadyToRunInstructionSet.Sha1; + case InstructionSet.ARM64_Sha1_Arm64: return ReadyToRunInstructionSet.Sha1; case InstructionSet.ARM64_Sha256: return ReadyToRunInstructionSet.Sha256; + case InstructionSet.ARM64_Sha256_Arm64: return ReadyToRunInstructionSet.Sha256; case InstructionSet.ARM64_Atomics: return ReadyToRunInstructionSet.Atomics; case InstructionSet.ARM64_Vector64: return null; case InstructionSet.ARM64_Vector128: return null; @@ -51,22 +54,29 @@ namespace Internal.ReadyToRunConstants case InstructionSet.X64_SSE2: return ReadyToRunInstructionSet.Sse2; case InstructionSet.X64_SSE2_X64: return ReadyToRunInstructionSet.Sse2; case InstructionSet.X64_SSE3: return ReadyToRunInstructionSet.Sse3; + case InstructionSet.X64_SSE3_X64: return ReadyToRunInstructionSet.Sse3; case InstructionSet.X64_SSSE3: return ReadyToRunInstructionSet.Ssse3; + case InstructionSet.X64_SSSE3_X64: return ReadyToRunInstructionSet.Ssse3; case InstructionSet.X64_SSE41: return ReadyToRunInstructionSet.Sse41; case InstructionSet.X64_SSE41_X64: return ReadyToRunInstructionSet.Sse41; case InstructionSet.X64_SSE42: return ReadyToRunInstructionSet.Sse42; case InstructionSet.X64_SSE42_X64: return ReadyToRunInstructionSet.Sse42; case InstructionSet.X64_AVX: return ReadyToRunInstructionSet.Avx; + case InstructionSet.X64_AVX_X64: return ReadyToRunInstructionSet.Avx; case InstructionSet.X64_AVX2: return ReadyToRunInstructionSet.Avx2; + case InstructionSet.X64_AVX2_X64: return ReadyToRunInstructionSet.Avx2; case InstructionSet.X64_AES: return ReadyToRunInstructionSet.Aes; + case InstructionSet.X64_AES_X64: return ReadyToRunInstructionSet.Aes; case InstructionSet.X64_BMI1: return ReadyToRunInstructionSet.Bmi1; case InstructionSet.X64_BMI1_X64: return ReadyToRunInstructionSet.Bmi1; case InstructionSet.X64_BMI2: return ReadyToRunInstructionSet.Bmi2; case InstructionSet.X64_BMI2_X64: return ReadyToRunInstructionSet.Bmi2; case InstructionSet.X64_FMA: return ReadyToRunInstructionSet.Fma; + case InstructionSet.X64_FMA_X64: return ReadyToRunInstructionSet.Fma; case InstructionSet.X64_LZCNT: return ReadyToRunInstructionSet.Lzcnt; case InstructionSet.X64_LZCNT_X64: return ReadyToRunInstructionSet.Lzcnt; case InstructionSet.X64_PCLMULQDQ: return ReadyToRunInstructionSet.Pclmulqdq; + case InstructionSet.X64_PCLMULQDQ_X64: return ReadyToRunInstructionSet.Pclmulqdq; case InstructionSet.X64_POPCNT: return ReadyToRunInstructionSet.Popcnt; case InstructionSet.X64_POPCNT_X64: return ReadyToRunInstructionSet.Popcnt; case InstructionSet.X64_Vector128: return null; diff --git a/src/coreclr/src/tools/Common/JitInterface/CorInfoInstructionSet.cs b/src/coreclr/src/tools/Common/JitInterface/CorInfoInstructionSet.cs index 745cf37..5257d47 100644 --- a/src/coreclr/src/tools/Common/JitInterface/CorInfoInstructionSet.cs +++ b/src/coreclr/src/tools/Common/JitInterface/CorInfoInstructionSet.cs @@ -18,17 +18,20 @@ namespace Internal.JitInterface ILLEGAL = 0, NONE = 63, ARM64_ArmBase=1, - ARM64_ArmBase_Arm64=2, - ARM64_AdvSimd=3, - ARM64_AdvSimd_Arm64=4, - ARM64_Aes=5, - ARM64_Crc32=6, - ARM64_Crc32_Arm64=7, - ARM64_Sha1=8, - ARM64_Sha256=9, - ARM64_Atomics=10, - ARM64_Vector64=11, - ARM64_Vector128=12, + ARM64_AdvSimd=2, + ARM64_Aes=3, + ARM64_Crc32=4, + ARM64_Sha1=5, + ARM64_Sha256=6, + ARM64_Atomics=7, + ARM64_Vector64=8, + ARM64_Vector128=9, + ARM64_ArmBase_Arm64=10, + ARM64_AdvSimd_Arm64=11, + ARM64_Aes_Arm64=12, + ARM64_Crc32_Arm64=13, + ARM64_Sha1_Arm64=14, + ARM64_Sha256_Arm64=15, X64_X86Base=1, X64_SSE=2, X64_SSE2=3, @@ -48,14 +51,21 @@ namespace Internal.JitInterface X64_Vector128=17, X64_Vector256=18, X64_X86Base_X64=19, - X64_BMI1_X64=20, - X64_BMI2_X64=21, - X64_LZCNT_X64=22, - X64_POPCNT_X64=23, - X64_SSE_X64=24, - X64_SSE2_X64=25, - X64_SSE41_X64=26, - X64_SSE42_X64=27, + X64_SSE_X64=20, + X64_SSE2_X64=21, + X64_SSE3_X64=22, + X64_SSSE3_X64=23, + X64_SSE41_X64=24, + X64_SSE42_X64=25, + X64_AVX_X64=26, + X64_AVX2_X64=27, + X64_AES_X64=28, + X64_BMI1_X64=29, + X64_BMI2_X64=30, + X64_FMA_X64=31, + X64_LZCNT_X64=32, + X64_PCLMULQDQ_X64=33, + X64_POPCNT_X64=34, X86_X86Base=1, X86_SSE=2, X86_SSE2=3, @@ -75,14 +85,21 @@ namespace Internal.JitInterface X86_Vector128=17, X86_Vector256=18, X86_X86Base_X64=19, - X86_BMI1_X64=20, - X86_BMI2_X64=21, - X86_LZCNT_X64=22, - X86_POPCNT_X64=23, - X86_SSE_X64=24, - X86_SSE2_X64=25, - X86_SSE41_X64=26, - X86_SSE42_X64=27, + X86_SSE_X64=20, + X86_SSE2_X64=21, + X86_SSE3_X64=22, + X86_SSSE3_X64=23, + X86_SSE41_X64=24, + X86_SSE42_X64=25, + X86_AVX_X64=26, + X86_AVX2_X64=27, + X86_AES_X64=28, + X86_BMI1_X64=29, + X86_BMI2_X64=30, + X86_FMA_X64=31, + X86_LZCNT_X64=32, + X86_PCLMULQDQ_X64=33, + X86_POPCNT_X64=34, } @@ -171,10 +188,22 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.ARM64_AdvSimd_Arm64); if (resultflags.HasInstructionSet(InstructionSet.ARM64_AdvSimd_Arm64)) resultflags.AddInstructionSet(InstructionSet.ARM64_AdvSimd); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Aes)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Aes_Arm64); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Aes_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Aes); if (resultflags.HasInstructionSet(InstructionSet.ARM64_Crc32)) resultflags.AddInstructionSet(InstructionSet.ARM64_Crc32_Arm64); if (resultflags.HasInstructionSet(InstructionSet.ARM64_Crc32_Arm64)) resultflags.AddInstructionSet(InstructionSet.ARM64_Crc32); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha1)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha1_Arm64); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha1_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha1); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha256)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha256_Arm64); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha256_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha256); if (resultflags.HasInstructionSet(InstructionSet.ARM64_AdvSimd)) resultflags.AddInstructionSet(InstructionSet.ARM64_ArmBase); if (resultflags.HasInstructionSet(InstructionSet.ARM64_Aes)) @@ -200,6 +229,14 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.X64_SSE2_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE2_X64)) resultflags.AddInstructionSet(InstructionSet.X64_SSE2); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSE3)) + resultflags.AddInstructionSet(InstructionSet.X64_SSE3_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSE3_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_SSE3); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSSE3)) + resultflags.AddInstructionSet(InstructionSet.X64_SSSE3_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSSE3_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_SSSE3); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE41)) resultflags.AddInstructionSet(InstructionSet.X64_SSE41_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE41_X64)) @@ -208,6 +245,18 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.X64_SSE42_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE42_X64)) resultflags.AddInstructionSet(InstructionSet.X64_SSE42); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX2)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX2_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX2_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX2); + if (resultflags.HasInstructionSet(InstructionSet.X64_AES)) + resultflags.AddInstructionSet(InstructionSet.X64_AES_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_AES_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AES); if (resultflags.HasInstructionSet(InstructionSet.X64_BMI1)) resultflags.AddInstructionSet(InstructionSet.X64_BMI1_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_BMI1_X64)) @@ -216,10 +265,18 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.X64_BMI2_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_BMI2_X64)) resultflags.AddInstructionSet(InstructionSet.X64_BMI2); + if (resultflags.HasInstructionSet(InstructionSet.X64_FMA)) + resultflags.AddInstructionSet(InstructionSet.X64_FMA_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_FMA_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_FMA); if (resultflags.HasInstructionSet(InstructionSet.X64_LZCNT)) resultflags.AddInstructionSet(InstructionSet.X64_LZCNT_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_LZCNT_X64)) resultflags.AddInstructionSet(InstructionSet.X64_LZCNT); + if (resultflags.HasInstructionSet(InstructionSet.X64_PCLMULQDQ)) + resultflags.AddInstructionSet(InstructionSet.X64_PCLMULQDQ_X64); + if (resultflags.HasInstructionSet(InstructionSet.X64_PCLMULQDQ_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_PCLMULQDQ); if (resultflags.HasInstructionSet(InstructionSet.X64_POPCNT)) resultflags.AddInstructionSet(InstructionSet.X64_POPCNT_X64); if (resultflags.HasInstructionSet(InstructionSet.X64_POPCNT_X64)) @@ -314,8 +371,14 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.ARM64_ArmBase); if (resultflags.HasInstructionSet(InstructionSet.ARM64_AdvSimd_Arm64)) resultflags.AddInstructionSet(InstructionSet.ARM64_AdvSimd); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Aes_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Aes); if (resultflags.HasInstructionSet(InstructionSet.ARM64_Crc32_Arm64)) resultflags.AddInstructionSet(InstructionSet.ARM64_Crc32); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha1_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha1); + if (resultflags.HasInstructionSet(InstructionSet.ARM64_Sha256_Arm64)) + resultflags.AddInstructionSet(InstructionSet.ARM64_Sha256); if (resultflags.HasInstructionSet(InstructionSet.ARM64_ArmBase)) resultflags.AddInstructionSet(InstructionSet.ARM64_AdvSimd); if (resultflags.HasInstructionSet(InstructionSet.ARM64_ArmBase)) @@ -335,16 +398,30 @@ namespace Internal.JitInterface resultflags.AddInstructionSet(InstructionSet.X64_SSE); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE2_X64)) resultflags.AddInstructionSet(InstructionSet.X64_SSE2); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSE3_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_SSE3); + if (resultflags.HasInstructionSet(InstructionSet.X64_SSSE3_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_SSSE3); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE41_X64)) resultflags.AddInstructionSet(InstructionSet.X64_SSE41); if (resultflags.HasInstructionSet(InstructionSet.X64_SSE42_X64)) resultflags.AddInstructionSet(InstructionSet.X64_SSE42); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX); + if (resultflags.HasInstructionSet(InstructionSet.X64_AVX2_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AVX2); + if (resultflags.HasInstructionSet(InstructionSet.X64_AES_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_AES); if (resultflags.HasInstructionSet(InstructionSet.X64_BMI1_X64)) resultflags.AddInstructionSet(InstructionSet.X64_BMI1); if (resultflags.HasInstructionSet(InstructionSet.X64_BMI2_X64)) resultflags.AddInstructionSet(InstructionSet.X64_BMI2); + if (resultflags.HasInstructionSet(InstructionSet.X64_FMA_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_FMA); if (resultflags.HasInstructionSet(InstructionSet.X64_LZCNT_X64)) resultflags.AddInstructionSet(InstructionSet.X64_LZCNT); + if (resultflags.HasInstructionSet(InstructionSet.X64_PCLMULQDQ_X64)) + resultflags.AddInstructionSet(InstructionSet.X64_PCLMULQDQ); if (resultflags.HasInstructionSet(InstructionSet.X64_POPCNT_X64)) resultflags.AddInstructionSet(InstructionSet.X64_POPCNT); if (resultflags.HasInstructionSet(InstructionSet.X64_X86Base)) @@ -505,8 +582,14 @@ namespace Internal.JitInterface AddInstructionSet(InstructionSet.ARM64_ArmBase_Arm64); if (HasInstructionSet(InstructionSet.ARM64_AdvSimd)) AddInstructionSet(InstructionSet.ARM64_AdvSimd_Arm64); + if (HasInstructionSet(InstructionSet.ARM64_Aes)) + AddInstructionSet(InstructionSet.ARM64_Aes_Arm64); if (HasInstructionSet(InstructionSet.ARM64_Crc32)) AddInstructionSet(InstructionSet.ARM64_Crc32_Arm64); + if (HasInstructionSet(InstructionSet.ARM64_Sha1)) + AddInstructionSet(InstructionSet.ARM64_Sha1_Arm64); + if (HasInstructionSet(InstructionSet.ARM64_Sha256)) + AddInstructionSet(InstructionSet.ARM64_Sha256_Arm64); break; case TargetArchitecture.X64: @@ -516,16 +599,30 @@ namespace Internal.JitInterface AddInstructionSet(InstructionSet.X64_SSE_X64); if (HasInstructionSet(InstructionSet.X64_SSE2)) AddInstructionSet(InstructionSet.X64_SSE2_X64); + if (HasInstructionSet(InstructionSet.X64_SSE3)) + AddInstructionSet(InstructionSet.X64_SSE3_X64); + if (HasInstructionSet(InstructionSet.X64_SSSE3)) + AddInstructionSet(InstructionSet.X64_SSSE3_X64); if (HasInstructionSet(InstructionSet.X64_SSE41)) AddInstructionSet(InstructionSet.X64_SSE41_X64); if (HasInstructionSet(InstructionSet.X64_SSE42)) AddInstructionSet(InstructionSet.X64_SSE42_X64); + if (HasInstructionSet(InstructionSet.X64_AVX)) + AddInstructionSet(InstructionSet.X64_AVX_X64); + if (HasInstructionSet(InstructionSet.X64_AVX2)) + AddInstructionSet(InstructionSet.X64_AVX2_X64); + if (HasInstructionSet(InstructionSet.X64_AES)) + AddInstructionSet(InstructionSet.X64_AES_X64); if (HasInstructionSet(InstructionSet.X64_BMI1)) AddInstructionSet(InstructionSet.X64_BMI1_X64); if (HasInstructionSet(InstructionSet.X64_BMI2)) AddInstructionSet(InstructionSet.X64_BMI2_X64); + if (HasInstructionSet(InstructionSet.X64_FMA)) + AddInstructionSet(InstructionSet.X64_FMA_X64); if (HasInstructionSet(InstructionSet.X64_LZCNT)) AddInstructionSet(InstructionSet.X64_LZCNT_X64); + if (HasInstructionSet(InstructionSet.X64_PCLMULQDQ)) + AddInstructionSet(InstructionSet.X64_PCLMULQDQ_X64); if (HasInstructionSet(InstructionSet.X64_POPCNT)) AddInstructionSet(InstructionSet.X64_POPCNT_X64); break; diff --git a/src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt b/src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt index 44a9139..73f5294 100644 --- a/src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt +++ b/src/coreclr/src/tools/Common/JitInterface/ThunkGenerator/InstructionSetDesc.txt @@ -16,72 +16,87 @@ ; copyinstructionsets,, ; Definition of X86 instruction sets - definearch ,X86 ,32Bit ,X64 + instructionset ,X86 ,X86Base , ,22 ,X86Base ,base instructionset ,X86 ,Sse , ,1 ,SSE ,sse -implication ,X86 ,SSE ,X86Base instructionset ,X86 ,Sse2 , ,2 ,SSE2 ,sse2 -implication ,X86 ,SSE2 ,SSE instructionset ,X86 ,Sse3 , ,3 ,SSE3 ,sse3 -implication ,X86 ,SSE3 ,SSE2 instructionset ,X86 ,Ssse3 , ,4 ,SSSE3 ,ssse3 -implication ,X86 ,SSSE3 ,SSE3 instructionset ,X86 ,Sse41 , ,5 ,SSE41 ,sse4.1 -implication ,X86 ,SSE41 ,SSSE3 instructionset ,X86 ,Sse42 , ,6 ,SSE42 ,sse4.2 -implication ,X86 ,SSE42 ,SSE41 instructionset ,X86 ,Avx , ,7 ,AVX ,avx -implication ,X86 ,AVX ,SSE42 instructionset ,X86 ,Avx2 , ,8 ,AVX2 ,avx2 -implication ,X86 ,AVX2 ,AVX instructionset ,X86 ,Aes , ,9 ,AES ,aes -implication ,X86 ,AES ,SSE2 instructionset ,X86 ,Bmi1 , ,10 ,BMI1 ,bmi -implication ,X86 ,BMI1 ,AVX instructionset ,X86 ,Bmi2 , ,11 ,BMI2 ,bmi2 -implication ,X86 ,BMI2 ,AVX instructionset ,X86 ,Fma , ,12 ,FMA ,fma -implication ,X86 ,FMA ,AVX instructionset ,X86 ,Lzcnt , ,13 ,LZCNT ,lzcnt instructionset ,X86 ,Pclmulqdq , ,14 ,PCLMULQDQ,pclmul -implication ,X86 ,PCLMULQDQ ,SSE2 instructionset ,X86 ,Popcnt , ,15 ,POPCNT ,popcnt -implication ,X86 ,POPCNT ,SSE42 instructionset ,X86 , , , ,Vector128, instructionset ,X86 , , , ,Vector256, -implication ,X86 ,Vector256 ,AVX -; Definition of X64 instruction sets (Define ) -definearch ,X64 ,64Bit ,X64 instructionset64bit,X86 ,X86Base -instructionset64bit,X86 ,BMI1 -instructionset64bit,X86 ,BMI2 -instructionset64bit,X86 ,LZCNT -instructionset64bit,X86 ,POPCNT instructionset64bit,X86 ,SSE instructionset64bit,X86 ,SSE2 +instructionset64bit,X86 ,SSE3 +instructionset64bit,X86 ,SSSE3 instructionset64bit,X86 ,SSE41 instructionset64bit,X86 ,SSE42 +instructionset64bit,X86 ,AVX +instructionset64bit,X86 ,AVX2 +instructionset64bit,X86 ,AES +instructionset64bit,X86 ,BMI1 +instructionset64bit,X86 ,BMI2 +instructionset64bit,X86 ,FMA +instructionset64bit,X86 ,LZCNT +instructionset64bit,X86 ,PCLMULQDQ +instructionset64bit,X86 ,POPCNT + +implication ,X86 ,SSE ,X86Base +implication ,X86 ,SSE2 ,SSE +implication ,X86 ,SSE3 ,SSE2 +implication ,X86 ,SSSE3 ,SSE3 +implication ,X86 ,SSE41 ,SSSE3 +implication ,X86 ,SSE42 ,SSE41 +implication ,X86 ,AVX ,SSE42 +implication ,X86 ,AVX2 ,AVX +implication ,X86 ,AES ,SSE2 +implication ,X86 ,BMI1 ,AVX +implication ,X86 ,BMI2 ,AVX +implication ,X86 ,FMA ,AVX +implication ,X86 ,PCLMULQDQ ,SSE2 +implication ,X86 ,POPCNT ,SSE42 +implication ,X86 ,Vector256 ,AVX + +; Definition of X64 instruction sets +definearch ,X64 ,64Bit ,X64 copyinstructionsets,X86 ,X64 -; Definition of the Arm64 instruction sets +; Definition of Arm64 instruction sets definearch ,ARM64 ,64Bit ,Arm64 + instructionset ,ARM64 ,ArmBase , ,16 ,ArmBase ,base -instructionset64bit,ARM64 ,ArmBase instructionset ,ARM64 ,AdvSimd , ,17 ,AdvSimd ,neon -instructionset64bit,ARM64 ,AdvSimd -implication ,ARM64 ,AdvSimd ,ArmBase instructionset ,ARM64 ,Aes , ,9 ,Aes ,aes -implication ,ARM64 ,Aes ,ArmBase instructionset ,ARM64 ,Crc32 , ,18 ,Crc32 ,crc -instructionset64bit,ARM64 ,Crc32 -implication ,ARM64 ,Crc32 ,ArmBase instructionset ,ARM64 ,Sha1 , ,19 ,Sha1 ,sha1 -implication ,ARM64 ,Sha1 ,ArmBase instructionset ,ARM64 ,Sha256 , ,20 ,Sha256 ,sha2 -implication ,ARM64 ,Sha256 ,ArmBase instructionset ,ARM64 , ,Atomics ,21 ,Atomics ,lse instructionset ,ARM64 , , , ,Vector64 , instructionset ,ARM64 , , , ,Vector128, + +instructionset64bit,ARM64 ,ArmBase +instructionset64bit,ARM64 ,AdvSimd +instructionset64bit,ARM64 ,Aes +instructionset64bit,ARM64 ,Crc32 +instructionset64bit,ARM64 ,Sha1 +instructionset64bit,ARM64 ,Sha256 + +implication ,ARM64 ,AdvSimd ,ArmBase +implication ,ARM64 ,Aes ,ArmBase +implication ,ARM64 ,Crc32 ,ArmBase +implication ,ARM64 ,Sha1 ,ArmBase +implication ,ARM64 ,Sha256 ,ArmBase diff --git a/src/coreclr/tests/issues.targets b/src/coreclr/tests/issues.targets index f05ee47..4e8fd38 100644 --- a/src/coreclr/tests/issues.targets +++ b/src/coreclr/tests/issues.targets @@ -1443,6 +1443,9 @@ needs triage + + needs triage + needs triage diff --git a/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs b/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs new file mode 100644 index 0000000..465557e --- /dev/null +++ b/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs @@ -0,0 +1,439 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.Arm; +using System.Runtime.Intrinsics.X86; + +using ArmAes = System.Runtime.Intrinsics.Arm.Aes; +using X86Aes = System.Runtime.Intrinsics.X86.Aes; + +class Runtime_34587 +{ + public static int Main() + { + bool succeeded = true; + + succeeded &= ValidateArm(); + succeeded &= ValidateX86(); + + return succeeded ? 100 : 0; + } + + private static bool ValidateArm() + { + bool succeeded = true; + + succeeded &= ValidateArmBase(); + succeeded &= ValidateAdvSimd(); + succeeded &= ValidateAes(); + succeeded &= ValidateCrc32(); + succeeded &= ValidateSha1(); + succeeded &= ValidateSha256(); + + return succeeded; + + static bool ValidateArmBase() + { + bool succeeded = true; + + if (ArmBase.IsSupported) + { + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.Arm64); + } + + if (ArmBase.Arm64.IsSupported) + { + succeeded &= ArmBase.IsSupported; + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.Arm64); + } + + return succeeded; + } + + static bool ValidateAdvSimd() + { + bool succeeded = true; + + if (AdvSimd.IsSupported) + { + succeeded &= ArmBase.IsSupported; + } + + if (AdvSimd.Arm64.IsSupported) + { + succeeded &= AdvSimd.IsSupported; + succeeded &= ArmBase.Arm64.IsSupported; + } + + return succeeded; + } + + static bool ValidateAes() + { + bool succeeded = true; + + if (ArmAes.IsSupported) + { + succeeded &= ArmBase.IsSupported; + } + + if (ArmAes.Arm64.IsSupported) + { + succeeded &= ArmAes.IsSupported; + succeeded &= ArmBase.Arm64.IsSupported; + } + + return succeeded; + } + + static bool ValidateCrc32() + { + bool succeeded = true; + + if (Crc32.IsSupported) + { + succeeded &= ArmBase.IsSupported; + } + + if (Crc32.Arm64.IsSupported) + { + succeeded &= Crc32.IsSupported; + succeeded &= ArmBase.Arm64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSha1() + { + bool succeeded = true; + + if (Sha1.IsSupported) + { + succeeded &= ArmBase.IsSupported; + } + + if (Sha1.Arm64.IsSupported) + { + succeeded &= Sha1.IsSupported; + succeeded &= ArmBase.Arm64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSha256() + { + bool succeeded = true; + + if (Sha256.IsSupported) + { + succeeded &= ArmBase.IsSupported; + } + + if (Sha256.Arm64.IsSupported) + { + succeeded &= Sha256.IsSupported; + succeeded &= ArmBase.Arm64.IsSupported; + } + + return succeeded; + } + } + + public static bool ValidateX86() + { + bool succeeded = true; + + succeeded &= ValidateSse(); + succeeded &= ValidateSse2(); + succeeded &= ValidateSse3(); + succeeded &= ValidateSsse3(); + succeeded &= ValidateSse41(); + succeeded &= ValidateSse42(); + succeeded &= ValidateAvx(); + succeeded &= ValidateAvx2(); + succeeded &= ValidateAes(); + succeeded &= ValidateBmi1(); + succeeded &= ValidateBmi2(); + succeeded &= ValidateFma(); + succeeded &= ValidateLzcnt(); + succeeded &= ValidatePclmulqdq(); + succeeded &= ValidatePopcnt(); + + return succeeded; + + static bool ValidateSse() + { + bool succeeded = true; + + if (Sse.IsSupported) + { + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X86) || (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + if (Sse.X64.IsSupported) + { + succeeded &= Sse.IsSupported; + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + return succeeded; + } + + static bool ValidateSse2() + { + bool succeeded = true; + + if (Sse2.IsSupported) + { + succeeded &= Sse.IsSupported; + } + + if (Sse2.X64.IsSupported) + { + succeeded &= Sse2.IsSupported; + succeeded &= Sse.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSse3() + { + bool succeeded = true; + + if (Sse3.IsSupported) + { + succeeded &= Sse2.IsSupported; + } + + if (Sse3.X64.IsSupported) + { + succeeded &= Sse3.IsSupported; + succeeded &= Sse2.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSsse3() + { + bool succeeded = true; + + if (Ssse3.IsSupported) + { + succeeded &= Sse3.IsSupported; + } + + if (Ssse3.X64.IsSupported) + { + succeeded &= Ssse3.IsSupported; + succeeded &= Sse3.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSse41() + { + bool succeeded = true; + + if (Sse41.IsSupported) + { + succeeded &= Ssse3.IsSupported; + } + + if (Sse41.X64.IsSupported) + { + succeeded &= Sse41.IsSupported; + succeeded &= Ssse3.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateSse42() + { + bool succeeded = true; + + if (Sse42.IsSupported) + { + succeeded &= Sse41.IsSupported; + } + + if (Sse42.X64.IsSupported) + { + succeeded &= Sse42.IsSupported; + succeeded &= Sse41.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateAvx() + { + bool succeeded = true; + + if (Avx.IsSupported) + { + succeeded &= Sse42.IsSupported; + } + + if (Avx.X64.IsSupported) + { + succeeded &= Avx.IsSupported; + succeeded &= Sse42.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateAvx2() + { + bool succeeded = true; + + if (Avx2.IsSupported) + { + succeeded &= Avx.IsSupported; + } + + if (Avx2.X64.IsSupported) + { + succeeded &= Avx2.IsSupported; + succeeded &= Avx.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateAes() + { + bool succeeded = true; + + if (X86Aes.IsSupported) + { + succeeded &= Sse2.IsSupported; + } + + if (X86Aes.X64.IsSupported) + { + succeeded &= X86Aes.IsSupported; + succeeded &= Sse2.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateBmi1() + { + bool succeeded = true; + + if (Bmi1.IsSupported) + { + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X86) || (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + if (Bmi1.X64.IsSupported) + { + succeeded &= Bmi1.IsSupported; + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + return succeeded; + } + + static bool ValidateBmi2() + { + bool succeeded = true; + + if (Bmi2.IsSupported) + { + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X86) || (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + if (Bmi2.X64.IsSupported) + { + succeeded &= Bmi2.IsSupported; + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + return succeeded; + } + + static bool ValidateFma() + { + bool succeeded = true; + + if (Fma.IsSupported) + { + succeeded &= Avx.IsSupported; + } + + if (Fma.X64.IsSupported) + { + succeeded &= Fma.IsSupported; + succeeded &= Avx.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidateLzcnt() + { + bool succeeded = true; + + if (Lzcnt.IsSupported) + { + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X86) || (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + if (Lzcnt.X64.IsSupported) + { + succeeded &= Lzcnt.IsSupported; + succeeded &= (RuntimeInformation.OSArchitecture == Architecture.X64); + } + + return succeeded; + } + + static bool ValidatePclmulqdq() + { + bool succeeded = true; + + if (Pclmulqdq.IsSupported) + { + succeeded &= Sse2.IsSupported; + } + + if (Pclmulqdq.X64.IsSupported) + { + succeeded &= Pclmulqdq.IsSupported; + succeeded &= Sse2.X64.IsSupported; + } + + return succeeded; + } + + static bool ValidatePopcnt() + { + bool succeeded = true; + + if (Popcnt.IsSupported) + { + succeeded &= Sse42.IsSupported; + } + + if (Popcnt.X64.IsSupported) + { + succeeded &= Popcnt.IsSupported; + succeeded &= Sse42.X64.IsSupported; + } + + return succeeded; + } + } +} diff --git a/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.csproj b/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.csproj new file mode 100644 index 0000000..5d49e8d --- /dev/null +++ b/src/coreclr/tests/src/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.csproj @@ -0,0 +1,13 @@ + + + Exe + + + + True + True + + + + + diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs index 2f506d6..a36723a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs @@ -16,6 +16,13 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { [Intrinsic] get => false; } + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) /// A32: AESD.8 Qd, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs index beb8e8c..f7067a9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) /// A32: AESD.8 Qd, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs index 31923f7..8dad58c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs @@ -16,6 +16,13 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { [Intrinsic] get => false; } + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// uint32_t vsha1h_u32 (uint32_t hash_e) /// A32: SHA1H.32 Qd, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs index 7fde64f..68e2e62 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// uint32_t vsha1h_u32 (uint32_t hash_e) /// A32: SHA1H.32 Qd, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs index 48948c7..e4af188 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs @@ -16,6 +16,13 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { [Intrinsic] get => false; } + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) /// A32: SHA256H.32 Qd, Qn, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs index 52b88f9..4416705 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.Arm public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class Arm64 : ArmBase.Arm64 + { + internal Arm64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) /// A32: SHA256H.32 Qd, Qn, Qm diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs index 08055b7..7a67d39 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) /// AESDEC xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs index 5c1ab7c..b72f6e3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) /// AESDEC xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs index 7bb09c4..01d674d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Sse42.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m256 _mm256_add_ps (__m256 a, __m256 b) /// VADDPS ymm, ymm, ymm/m256 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs index fcf4bd5..3ab8aff 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs @@ -16,6 +16,15 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Sse42.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + + /// /// __m256 _mm256_add_ps (__m256 a, __m256 b) /// VADDPS ymm, ymm, ymm/m256 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs index 8d3a8fa..28ae4c7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Avx.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m256i _mm256_abs_epi8 (__m256i a) /// VPABSB ymm, ymm/m256 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs index a491fae..c6ab668 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Avx.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m256i _mm256_abs_epi8 (__m256i a) /// VPABSB ymm, ymm/m256 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs index c824708..045a8a2 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs @@ -11,13 +11,13 @@ namespace System.Runtime.Intrinsics.X86 /// This class provides access to Intel BMI1 hardware instructions via intrinsics /// [CLSCompliant(false)] - public abstract class Bmi1 + public abstract class Bmi1 // : X86Base { internal Bmi1() { } public static bool IsSupported { [Intrinsic] get { return false; } } - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs index 68a832a..535d5f7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs @@ -10,14 +10,14 @@ namespace System.Runtime.Intrinsics.X86 /// [Intrinsic] [CLSCompliant(false)] - public abstract class Bmi1 + public abstract class Bmi1 // : X86Base { internal Bmi1() { } public static bool IsSupported { get => IsSupported; } [Intrinsic] - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs index 892e8fa..08a4204 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs @@ -11,13 +11,13 @@ namespace System.Runtime.Intrinsics.X86 /// This class provides access to Intel BMI2 hardware instructions via intrinsics /// [CLSCompliant(false)] - public abstract class Bmi2 + public abstract class Bmi2 // : X86Base { internal Bmi2() { } public static bool IsSupported { [Intrinsic] get { return false; } } - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs index e8ab103..81dff57 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs @@ -10,14 +10,14 @@ namespace System.Runtime.Intrinsics.X86 /// [Intrinsic] [CLSCompliant(false)] - public abstract class Bmi2 + public abstract class Bmi2 // : X86Base { internal Bmi2() { } public static bool IsSupported { get => IsSupported; } [Intrinsic] - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs index 4f5799e..64b3024 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Avx.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) /// VFMADDPS xmm, xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs index 0faa105..d147e8b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Avx.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) /// VFMADDPS xmm, xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs index 7845f65..a800021 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs @@ -10,13 +10,13 @@ namespace System.Runtime.Intrinsics.X86 /// This class provides access to Intel LZCNT hardware instructions via intrinsics /// [CLSCompliant(false)] - public abstract class Lzcnt + public abstract class Lzcnt // : X86Base { internal Lzcnt() { } public static bool IsSupported { [Intrinsic] get { return false; } } - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs index 81bf292..d6d278c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs @@ -10,14 +10,14 @@ namespace System.Runtime.Intrinsics.X86 /// [Intrinsic] [CLSCompliant(false)] - public abstract class Lzcnt + public abstract class Lzcnt // : X86Base { internal Lzcnt() { } public static bool IsSupported { get => IsSupported; } [Intrinsic] - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs index 76b9362..eb1cd76 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) /// PCLMULQDQ xmm, xmm/m128, imm8 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs index 07679df..b20c8c7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) /// PCLMULQDQ xmm, xmm/m128, imm8 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs index de3ad96..28bfe8f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs @@ -16,7 +16,7 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } - public new abstract class X64 : Sse41.X64 + public new abstract class X64 : Sse42.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs index 33883c8..3fdeffe 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs @@ -17,10 +17,12 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } [Intrinsic] - public new abstract class X64 : Sse41.X64 + public new abstract class X64 : Sse42.X64 { internal X64() { } + public static new bool IsSupported { get => IsSupported; } + /// /// __int64 _mm_popcnt_u64 (unsigned __int64 a) /// POPCNT reg64, reg/m64 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs index 9066f15..00d3c68 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs @@ -11,13 +11,13 @@ namespace System.Runtime.Intrinsics.X86 /// This class provides access to Intel SSE hardware instructions via intrinsics /// [CLSCompliant(false)] - public abstract class Sse + public abstract class Sse // : X86Base { internal Sse() { } public static bool IsSupported { [Intrinsic] get { return false; } } - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs index de3999b..1e88751 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs @@ -10,14 +10,14 @@ namespace System.Runtime.Intrinsics.X86 /// [Intrinsic] [CLSCompliant(false)] - public abstract class Sse + public abstract class Sse // : X86Base { internal Sse() { } public static bool IsSupported { get => IsSupported; } [Intrinsic] - public abstract class X64 + public abstract class X64 // : X86Base.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs index a6df721..368557d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m128 _mm_addsub_ps (__m128 a, __m128 b) /// ADDSUBPS xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs index 75e6746..2ec3f9b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Sse2.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m128 _mm_addsub_ps (__m128 a, __m128 b) /// ADDSUBPS xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs index c695e29..a207c6c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs @@ -17,7 +17,7 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } - public new abstract class X64 : Sse2.X64 + public new abstract class X64 : Ssse3.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs index 45d05c1..f0a7f00 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs @@ -17,7 +17,7 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } [Intrinsic] - public new abstract class X64 : Sse2.X64 + public new abstract class X64 : Ssse3.X64 { internal X64() { } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs index 2c546f6..4129d8c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs @@ -17,6 +17,13 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { [Intrinsic] get { return false; } } + public new abstract class X64 : Sse3.X64 + { + internal X64() { } + + public static new bool IsSupported { [Intrinsic] get { return false; } } + } + /// /// __m128i _mm_abs_epi8 (__m128i a) /// PABSB xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs index 64d4c75..68d33bd 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs @@ -16,6 +16,14 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get => IsSupported; } + [Intrinsic] + public new abstract class X64 : Sse3.X64 + { + internal X64() { } + + public static new bool IsSupported { get => IsSupported; } + } + /// /// __m128i _mm_abs_epi8 (__m128i a) /// PABSB xmm, xmm/m128 diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs index 7edfefa..a0e0e68 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs @@ -9,12 +9,16 @@ namespace System.Runtime.Intrinsics.X86 /// /// This class provides access to the x86 base hardware instructions via intrinsics /// - internal static class X86Base + internal abstract class X86Base { + internal X86Base() { } + public static bool IsSupported { [Intrinsic] get => false; } - internal static class X64 + internal abstract class X64 { + internal X64() { } + public static bool IsSupported { [Intrinsic] get => false; } /// diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs index 879fe66..de49813 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs @@ -9,12 +9,12 @@ namespace System.Runtime.Intrinsics.X86 /// This class provides access to the x86 base hardware instructions via intrinsics /// [Intrinsic] - internal static class X86Base + internal abstract class X86Base { public static bool IsSupported { get => IsSupported; } [Intrinsic] - internal static class X64 + internal abstract class X64 { public static bool IsSupported { get => IsSupported; } diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index 0a227bb..695ed82 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -114,9 +114,9 @@ namespace System.Runtime.Intrinsics public readonly partial struct Vector128 : System.IEquatable> where T : struct { private readonly int _dummyPrimitive; + public static System.Runtime.Intrinsics.Vector128 AllBitsSet { get { throw null; } } public static int Count { get { throw null; } } public static System.Runtime.Intrinsics.Vector128 Zero { get { throw null; } } - public static System.Runtime.Intrinsics.Vector128 AllBitsSet { get { throw null; } } public override bool Equals(object? obj) { throw null; } public bool Equals(System.Runtime.Intrinsics.Vector128 other) { throw null; } public override int GetHashCode() { throw null; } @@ -222,9 +222,9 @@ namespace System.Runtime.Intrinsics public readonly partial struct Vector256 : System.IEquatable> where T : struct { private readonly int _dummyPrimitive; + public static System.Runtime.Intrinsics.Vector256 AllBitsSet { get { throw null; } } public static int Count { get { throw null; } } public static System.Runtime.Intrinsics.Vector256 Zero { get { throw null; } } - public static System.Runtime.Intrinsics.Vector256 AllBitsSet { get { throw null; } } public override bool Equals(object? obj) { throw null; } public bool Equals(System.Runtime.Intrinsics.Vector256 other) { throw null; } public override int GetHashCode() { throw null; } @@ -304,9 +304,9 @@ namespace System.Runtime.Intrinsics public readonly partial struct Vector64 : System.IEquatable> where T : struct { private readonly int _dummyPrimitive; + public static System.Runtime.Intrinsics.Vector64 AllBitsSet { get { throw null; } } public static int Count { get { throw null; } } public static System.Runtime.Intrinsics.Vector64 Zero { get { throw null; } } - public static System.Runtime.Intrinsics.Vector64 AllBitsSet { get { throw null; } } public override bool Equals(object? obj) { throw null; } public bool Equals(System.Runtime.Intrinsics.Vector64 other) { throw null; } public override int GetHashCode() { throw null; } @@ -2494,6 +2494,11 @@ namespace System.Runtime.Intrinsics.Arm public static System.Runtime.Intrinsics.Vector128 PolynomialMultiplyWideningLower(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right) { throw null; } public static System.Runtime.Intrinsics.Vector128 PolynomialMultiplyWideningUpper(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } public static System.Runtime.Intrinsics.Vector128 PolynomialMultiplyWideningUpper(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } + public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.ArmBase.Arm64 + { + internal Arm64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class ArmBase @@ -2546,6 +2551,11 @@ namespace System.Runtime.Intrinsics.Arm public static System.Runtime.Intrinsics.Vector128 HashUpdateParity(System.Runtime.Intrinsics.Vector128 hash_abcd, System.Runtime.Intrinsics.Vector64 hash_e, System.Runtime.Intrinsics.Vector128 wk) { throw null; } public static System.Runtime.Intrinsics.Vector128 ScheduleUpdate0(System.Runtime.Intrinsics.Vector128 w0_3, System.Runtime.Intrinsics.Vector128 w4_7, System.Runtime.Intrinsics.Vector128 w8_11) { throw null; } public static System.Runtime.Intrinsics.Vector128 ScheduleUpdate1(System.Runtime.Intrinsics.Vector128 tw0_3, System.Runtime.Intrinsics.Vector128 w12_15) { throw null; } + public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.ArmBase.Arm64 + { + internal Arm64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Sha256 : System.Runtime.Intrinsics.Arm.ArmBase @@ -2556,6 +2566,11 @@ namespace System.Runtime.Intrinsics.Arm public static System.Runtime.Intrinsics.Vector128 HashUpdate2(System.Runtime.Intrinsics.Vector128 hash_efgh, System.Runtime.Intrinsics.Vector128 hash_abcd, System.Runtime.Intrinsics.Vector128 wk) { throw null; } public static System.Runtime.Intrinsics.Vector128 ScheduleUpdate0(System.Runtime.Intrinsics.Vector128 w0_3, System.Runtime.Intrinsics.Vector128 w4_7) { throw null; } public static System.Runtime.Intrinsics.Vector128 ScheduleUpdate1(System.Runtime.Intrinsics.Vector128 w0_3, System.Runtime.Intrinsics.Vector128 w8_11, System.Runtime.Intrinsics.Vector128 w12_15) { throw null; } + public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.ArmBase.Arm64 + { + internal Arm64() { } + public static new bool IsSupported { get { throw null; } } + } } } namespace System.Runtime.Intrinsics.X86 @@ -2571,6 +2586,11 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector128 EncryptLast(System.Runtime.Intrinsics.Vector128 value, System.Runtime.Intrinsics.Vector128 roundKey) { throw null; } public static System.Runtime.Intrinsics.Vector128 InverseMixColumns(System.Runtime.Intrinsics.Vector128 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 KeygenAssist(System.Runtime.Intrinsics.Vector128 value, byte control) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Avx : System.Runtime.Intrinsics.X86.Sse42 @@ -2820,6 +2840,11 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector256 UnpackLow(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse42.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Avx2 : System.Runtime.Intrinsics.X86.Avx @@ -3219,6 +3244,11 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } public static System.Runtime.Intrinsics.Vector256 Xor(System.Runtime.Intrinsics.Vector256 left, System.Runtime.Intrinsics.Vector256 right) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Avx.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Bmi1 @@ -3338,6 +3368,11 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector128 MultiplySubtractNegatedScalar(System.Runtime.Intrinsics.Vector128 a, System.Runtime.Intrinsics.Vector128 b, System.Runtime.Intrinsics.Vector128 c) { throw null; } public static System.Runtime.Intrinsics.Vector128 MultiplySubtractScalar(System.Runtime.Intrinsics.Vector128 a, System.Runtime.Intrinsics.Vector128 b, System.Runtime.Intrinsics.Vector128 c) { throw null; } public static System.Runtime.Intrinsics.Vector128 MultiplySubtractScalar(System.Runtime.Intrinsics.Vector128 a, System.Runtime.Intrinsics.Vector128 b, System.Runtime.Intrinsics.Vector128 c) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Avx.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Lzcnt @@ -3359,6 +3394,11 @@ namespace System.Runtime.Intrinsics.X86 public static new bool IsSupported { get { throw null; } } public static System.Runtime.Intrinsics.Vector128 CarrylessMultiply(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte control) { throw null; } public static System.Runtime.Intrinsics.Vector128 CarrylessMultiply(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte control) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Popcnt : System.Runtime.Intrinsics.X86.Sse42 @@ -3366,7 +3406,7 @@ namespace System.Runtime.Intrinsics.X86 internal Popcnt() { } public static new bool IsSupported { get { throw null; } } public static uint PopCount(uint value) { throw null; } - public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse41.X64 + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse42.X64 { internal X64() { } public static new bool IsSupported { get { throw null; } } @@ -3816,6 +3856,11 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector128 MoveAndDuplicate(System.Runtime.Intrinsics.Vector128 source) { throw null; } public static System.Runtime.Intrinsics.Vector128 MoveHighAndDuplicate(System.Runtime.Intrinsics.Vector128 source) { throw null; } public static System.Runtime.Intrinsics.Vector128 MoveLowAndDuplicate(System.Runtime.Intrinsics.Vector128 source) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } [System.CLSCompliantAttribute(false)] public abstract partial class Sse41 : System.Runtime.Intrinsics.X86.Ssse3 @@ -3961,7 +4006,7 @@ namespace System.Runtime.Intrinsics.X86 public static bool TestZ(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } public static bool TestZ(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } public static bool TestZ(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } - public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64 + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Ssse3.X64 { internal X64() { } public static new bool IsSupported { get { throw null; } } @@ -4016,5 +4061,10 @@ namespace System.Runtime.Intrinsics.X86 public static System.Runtime.Intrinsics.Vector128 Sign(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } public static System.Runtime.Intrinsics.Vector128 Sign(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } public static System.Runtime.Intrinsics.Vector128 Sign(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right) { throw null; } + public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse3.X64 + { + internal X64() { } + public static new bool IsSupported { get { throw null; } } + } } }