* 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
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,
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,
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
};
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))
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
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))
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))
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))
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))
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 :
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 :
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 :
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 :
{
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;
}
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:
{
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:
{
// 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:
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:
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:
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;
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;
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,
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,
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,
}
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))
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))
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))
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))
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))
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))
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:
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;
; copyinstructionsets,<architecture>,<copytoarchitecture>
; 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
<ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/JitBlue/GitHub_4044/**">
<Issue>needs triage</Issue>
</ExcludeList>
+ <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_34587/**">
+ <Issue>needs triage</Issue>
+ </ExcludeList>
<ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/VS-ia64-JIT/V1.2-M02/b10828/**">
<Issue>needs triage</Issue>
</ExcludeList>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+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;
+ }
+ }
+}
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType />
+ <Optimize>True</Optimize>
+ <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>
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; } }
+ }
+
/// <summary>
/// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key)
/// A32: AESD.8 Qd, Qm
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class Arm64 : ArmBase.Arm64
+ {
+ internal Arm64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key)
/// A32: AESD.8 Qd, Qm
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; } }
+ }
+
/// <summary>
/// uint32_t vsha1h_u32 (uint32_t hash_e)
/// A32: SHA1H.32 Qd, Qm
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class Arm64 : ArmBase.Arm64
+ {
+ internal Arm64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// uint32_t vsha1h_u32 (uint32_t hash_e)
/// A32: SHA1H.32 Qd, Qm
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; } }
+ }
+
/// <summary>
/// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
/// A32: SHA256H.32 Qd, Qn, Qm
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class Arm64 : ArmBase.Arm64
+ {
+ internal Arm64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
/// A32: SHA256H.32 Qd, Qn, Qm
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; } }
+ }
+
/// <summary>
/// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
/// AESDEC xmm, xmm/m128
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Sse2.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
/// AESDEC xmm, xmm/m128
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; } }
+ }
+
/// <summary>
/// __m256 _mm256_add_ps (__m256 a, __m256 b)
/// VADDPS ymm, ymm, ymm/m256
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Sse42.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
+
/// <summary>
/// __m256 _mm256_add_ps (__m256 a, __m256 b)
/// VADDPS ymm, ymm, ymm/m256
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; } }
+ }
+
/// <summary>
/// __m256i _mm256_abs_epi8 (__m256i a)
/// VPABSB ymm, ymm/m256
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Avx.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m256i _mm256_abs_epi8 (__m256i a)
/// VPABSB ymm, ymm/m256
/// This class provides access to Intel BMI1 hardware instructions via intrinsics
/// </summary>
[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() { }
/// </summary>
[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() { }
/// This class provides access to Intel BMI2 hardware instructions via intrinsics
/// </summary>
[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() { }
/// </summary>
[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() { }
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; } }
+ }
+
/// <summary>
/// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c)
/// VFMADDPS xmm, xmm, xmm/m128
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Avx.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c)
/// VFMADDPS xmm, xmm, xmm/m128
/// This class provides access to Intel LZCNT hardware instructions via intrinsics
/// </summary>
[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() { }
/// </summary>
[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() { }
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; } }
+ }
+
/// <summary>
/// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
/// PCLMULQDQ xmm, xmm/m128, imm8
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Sse2.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
/// PCLMULQDQ xmm, xmm/m128, imm8
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() { }
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; }
+
/// <summary>
/// __int64 _mm_popcnt_u64 (unsigned __int64 a)
/// POPCNT reg64, reg/m64
/// This class provides access to Intel SSE hardware instructions via intrinsics
/// </summary>
[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() { }
/// </summary>
[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() { }
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; } }
+ }
+
/// <summary>
/// __m128 _mm_addsub_ps (__m128 a, __m128 b)
/// ADDSUBPS xmm, xmm/m128
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Sse2.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m128 _mm_addsub_ps (__m128 a, __m128 b)
/// ADDSUBPS xmm, xmm/m128
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() { }
public static new bool IsSupported { get => IsSupported; }
[Intrinsic]
- public new abstract class X64 : Sse2.X64
+ public new abstract class X64 : Ssse3.X64
{
internal X64() { }
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; } }
+ }
+
/// <summary>
/// __m128i _mm_abs_epi8 (__m128i a)
/// PABSB xmm, xmm/m128
public static new bool IsSupported { get => IsSupported; }
+ [Intrinsic]
+ public new abstract class X64 : Sse3.X64
+ {
+ internal X64() { }
+
+ public static new bool IsSupported { get => IsSupported; }
+ }
+
/// <summary>
/// __m128i _mm_abs_epi8 (__m128i a)
/// PABSB xmm, xmm/m128
/// <summary>
/// This class provides access to the x86 base hardware instructions via intrinsics
/// </summary>
- 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; }
/// <summary>
/// This class provides access to the x86 base hardware instructions via intrinsics
/// </summary>
[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; }
public readonly partial struct Vector128<T> : System.IEquatable<System.Runtime.Intrinsics.Vector128<T>> where T : struct
{
private readonly int _dummyPrimitive;
+ public static System.Runtime.Intrinsics.Vector128<T> AllBitsSet { get { throw null; } }
public static int Count { get { throw null; } }
public static System.Runtime.Intrinsics.Vector128<T> Zero { get { throw null; } }
- public static System.Runtime.Intrinsics.Vector128<T> AllBitsSet { get { throw null; } }
public override bool Equals(object? obj) { throw null; }
public bool Equals(System.Runtime.Intrinsics.Vector128<T> other) { throw null; }
public override int GetHashCode() { throw null; }
public readonly partial struct Vector256<T> : System.IEquatable<System.Runtime.Intrinsics.Vector256<T>> where T : struct
{
private readonly int _dummyPrimitive;
+ public static System.Runtime.Intrinsics.Vector256<T> AllBitsSet { get { throw null; } }
public static int Count { get { throw null; } }
public static System.Runtime.Intrinsics.Vector256<T> Zero { get { throw null; } }
- public static System.Runtime.Intrinsics.Vector256<T> AllBitsSet { get { throw null; } }
public override bool Equals(object? obj) { throw null; }
public bool Equals(System.Runtime.Intrinsics.Vector256<T> other) { throw null; }
public override int GetHashCode() { throw null; }
public readonly partial struct Vector64<T> : System.IEquatable<System.Runtime.Intrinsics.Vector64<T>> where T : struct
{
private readonly int _dummyPrimitive;
+ public static System.Runtime.Intrinsics.Vector64<T> AllBitsSet { get { throw null; } }
public static int Count { get { throw null; } }
public static System.Runtime.Intrinsics.Vector64<T> Zero { get { throw null; } }
- public static System.Runtime.Intrinsics.Vector64<T> AllBitsSet { get { throw null; } }
public override bool Equals(object? obj) { throw null; }
public bool Equals(System.Runtime.Intrinsics.Vector64<T> other) { throw null; }
public override int GetHashCode() { throw null; }
public static System.Runtime.Intrinsics.Vector128<ulong> PolynomialMultiplyWideningLower(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<long> PolynomialMultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<ulong> PolynomialMultiplyWideningUpper(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> 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
public static System.Runtime.Intrinsics.Vector128<uint> HashUpdateParity(System.Runtime.Intrinsics.Vector128<uint> hash_abcd, System.Runtime.Intrinsics.Vector64<uint> hash_e, System.Runtime.Intrinsics.Vector128<uint> wk) { throw null; }
public static System.Runtime.Intrinsics.Vector128<uint> ScheduleUpdate0(System.Runtime.Intrinsics.Vector128<uint> w0_3, System.Runtime.Intrinsics.Vector128<uint> w4_7, System.Runtime.Intrinsics.Vector128<uint> w8_11) { throw null; }
public static System.Runtime.Intrinsics.Vector128<uint> ScheduleUpdate1(System.Runtime.Intrinsics.Vector128<uint> tw0_3, System.Runtime.Intrinsics.Vector128<uint> 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
public static System.Runtime.Intrinsics.Vector128<uint> HashUpdate2(System.Runtime.Intrinsics.Vector128<uint> hash_efgh, System.Runtime.Intrinsics.Vector128<uint> hash_abcd, System.Runtime.Intrinsics.Vector128<uint> wk) { throw null; }
public static System.Runtime.Intrinsics.Vector128<uint> ScheduleUpdate0(System.Runtime.Intrinsics.Vector128<uint> w0_3, System.Runtime.Intrinsics.Vector128<uint> w4_7) { throw null; }
public static System.Runtime.Intrinsics.Vector128<uint> ScheduleUpdate1(System.Runtime.Intrinsics.Vector128<uint> w0_3, System.Runtime.Intrinsics.Vector128<uint> w8_11, System.Runtime.Intrinsics.Vector128<uint> 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
public static System.Runtime.Intrinsics.Vector128<byte> EncryptLast(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> roundKey) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> InverseMixColumns(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
public static System.Runtime.Intrinsics.Vector128<byte> KeygenAssist(System.Runtime.Intrinsics.Vector128<byte> 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
public static System.Runtime.Intrinsics.Vector256<float> UnpackLow(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
public static System.Runtime.Intrinsics.Vector256<double> Xor(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
public static System.Runtime.Intrinsics.Vector256<float> Xor(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> 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
public static System.Runtime.Intrinsics.Vector256<ushort> Xor(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
public static System.Runtime.Intrinsics.Vector256<uint> Xor(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
public static System.Runtime.Intrinsics.Vector256<ulong> Xor(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> 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
public static System.Runtime.Intrinsics.Vector128<float> MultiplySubtractNegatedScalar(System.Runtime.Intrinsics.Vector128<float> a, System.Runtime.Intrinsics.Vector128<float> b, System.Runtime.Intrinsics.Vector128<float> c) { throw null; }
public static System.Runtime.Intrinsics.Vector128<double> MultiplySubtractScalar(System.Runtime.Intrinsics.Vector128<double> a, System.Runtime.Intrinsics.Vector128<double> b, System.Runtime.Intrinsics.Vector128<double> c) { throw null; }
public static System.Runtime.Intrinsics.Vector128<float> MultiplySubtractScalar(System.Runtime.Intrinsics.Vector128<float> a, System.Runtime.Intrinsics.Vector128<float> b, System.Runtime.Intrinsics.Vector128<float> 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
public static new bool IsSupported { get { throw null; } }
public static System.Runtime.Intrinsics.Vector128<long> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte control) { throw null; }
public static System.Runtime.Intrinsics.Vector128<ulong> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> 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
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; } }
public static System.Runtime.Intrinsics.Vector128<double> MoveAndDuplicate(System.Runtime.Intrinsics.Vector128<double> source) { throw null; }
public static System.Runtime.Intrinsics.Vector128<float> MoveHighAndDuplicate(System.Runtime.Intrinsics.Vector128<float> source) { throw null; }
public static System.Runtime.Intrinsics.Vector128<float> MoveLowAndDuplicate(System.Runtime.Intrinsics.Vector128<float> 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
public static bool TestZ(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
public static bool TestZ(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
public static bool TestZ(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> 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; } }
public static System.Runtime.Intrinsics.Vector128<short> Sign(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<int> Sign(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
public static System.Runtime.Intrinsics.Vector128<sbyte> Sign(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> 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; } }
+ }
}
}
projects / platform / upstream / dotnet / runtime.git / commitdiff