Skip to content

Remove ymm embedded rounding from AVX10.2 #115235

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
tannergooding merged 3 commits into from
May 8, 2025
Merged

Remove ymm embedded rounding from AVX10.2 #115235

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
384a720
Revert ymm embedded rounding
khushal1996 Apr 30, 2025
5505b9b
Merge branch 'main' into kcm-avx102-revert-public-pr
tannergooding May 8, 2025
ed72f8b
Merge branch 'main' into kcm-avx102-revert-public-pr
khushal1996 May 8, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 0 additions & 11 deletions src/coreclr/jit/emitxarch.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1980,9 +1980,6 @@ bool emitter::TakesApxExtendedEvexPrefix(const instrDesc* id) const
// - V'- bit to extend vvvv
// - aaa - specifies mask register
// Rest - reserved for future use and usage of them will uresult in Undefined instruction exception.
// - u - Bit to indicate YMM Embedded rounding.
// Set to 1 for isas Avx10.1 and below
// Needs to be set to 0 for AVX10.2 and above to indicate YMM embedded rounding
// - B' - reserved as of now
// set to 0 for future compatibility.
//
Expand All @@ -1993,7 +1990,6 @@ bool emitter::TakesApxExtendedEvexPrefix(const instrDesc* id) const
#define LBIT_IN_BYTE_EVEX_PREFIX 0x0000002000000000ULL
#define LPRIMEBIT_IN_BYTE_EVEX_PREFIX 0x0000004000000000ULL
#define ZBIT_IN_BYTE_EVEX_PREFIX 0x0000008000000000ULL
#define uBIT_IN_BYTE_EVEX_PREFIX 0x0000040000000000ULL

#define MAP4_IN_BYTE_EVEX_PREFIX 0x4000000000000ULL
#define ND_BIT_IN_BYTE_EVEX_PREFIX 0x1000000000ULL
Expand Down Expand Up @@ -2100,13 +2096,6 @@ emitter::code_t emitter::AddEvexPrefix(const instrDesc* id, code_t code, emitAtt

if (!id->idHasMem())
{
// ymm embedded rounding case.
if (attr == EA_32BYTE)
{
assert(emitComp->compIsaSupportedDebugOnly(InstructionSet_AVX10v2));
code &= ~(uBIT_IN_BYTE_EVEX_PREFIX);
}

unsigned roundingMode = id->idGetEvexbContext();
if (roundingMode == 1)
{
Expand Down
21 changes: 0 additions & 21 deletions src/coreclr/jit/gentree.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28644,21 +28644,6 @@ bool GenTreeHWIntrinsic::OperIsEmbRoundingEnabled() const
case NI_AVX10v1_MultiplyScalar:
case NI_AVX10v1_SubtractScalar:
case NI_AVX10v1_SqrtScalar:
case NI_AVX10v2_Add:
case NI_AVX10v2_ConvertToVector128Int32:
case NI_AVX10v2_ConvertToVector128Single:
case NI_AVX10v2_ConvertToVector128UInt32:
case NI_AVX10v2_ConvertToVector256Double:
case NI_AVX10v2_ConvertToVector256Int32:
case NI_AVX10v2_ConvertToVector256Int64:
case NI_AVX10v2_ConvertToVector256Single:
case NI_AVX10v2_ConvertToVector256UInt32:
case NI_AVX10v2_ConvertToVector256UInt64:
case NI_AVX10v2_Divide:
case NI_AVX10v2_Multiply:
case NI_AVX10v2_Scale:
case NI_AVX10v2_Sqrt:
case NI_AVX10v2_Subtract:
{
return true;
}
Expand Down Expand Up @@ -28727,8 +28712,6 @@ bool GenTreeHWIntrinsic::OperIsEmbRoundingEnabled() const
case NI_AVX10v1_V512_ConvertToVector512Double:
case NI_AVX10v1_V512_ConvertToVector512Int64:
case NI_AVX10v1_V512_ConvertToVector512UInt64:
case NI_AVX10v2_ConvertToSByteWithSaturationAndZeroExtendToInt32:
case NI_AVX10v2_ConvertToByteWithSaturationAndZeroExtendToInt32:
case NI_AVX10v2_V512_ConvertToSByteWithSaturationAndZeroExtendToInt32:
case NI_AVX10v2_V512_ConvertToByteWithSaturationAndZeroExtendToInt32:
{
Expand Down Expand Up @@ -29113,7 +29096,6 @@ genTreeOps GenTreeHWIntrinsic::GetOperForHWIntrinsicId(NamedIntrinsic id, var_ty
case NI_AVX_Add:
case NI_AVX2_Add:
case NI_AVX512F_Add:
case NI_AVX10v2_Add:
case NI_AVX512BW_Add:
#elif defined(TARGET_ARM64)
case NI_AdvSimd_Add:
Expand Down Expand Up @@ -29150,7 +29132,6 @@ genTreeOps GenTreeHWIntrinsic::GetOperForHWIntrinsicId(NamedIntrinsic id, var_ty
case NI_SSE2_Divide:
case NI_AVX_Divide:
case NI_AVX512F_Divide:
case NI_AVX10v2_Divide:
#elif defined(TARGET_ARM64)
case NI_AdvSimd_Arm64_Divide:
#endif
Expand Down Expand Up @@ -29203,7 +29184,6 @@ genTreeOps GenTreeHWIntrinsic::GetOperForHWIntrinsicId(NamedIntrinsic id, var_ty
#if defined(TARGET_XARCH)
case NI_SSE2_Multiply:
case NI_AVX512F_Multiply:
case NI_AVX10v2_Multiply:
{
if (varTypeIsFloating(simdBaseType))
{
Expand Down Expand Up @@ -29369,7 +29349,6 @@ genTreeOps GenTreeHWIntrinsic::GetOperForHWIntrinsicId(NamedIntrinsic id, var_ty
case NI_AVX2_Subtract:
case NI_AVX512F_Subtract:
case NI_AVX512BW_Subtract:
case NI_AVX10v2_Subtract:
#elif defined(TARGET_ARM64)
case NI_AdvSimd_Subtract:
case NI_AdvSimd_Arm64_Subtract:
Expand Down
23 changes: 4 additions & 19 deletions src/coreclr/jit/hwintrinsiclistxarch.h
View file
Open in desktop

Large diffs are not rendered by default.

145 changes: 0 additions & 145 deletions .../System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v2.PlatformNotSupported.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,26 +49,6 @@ internal Avx10v2() { }
/// </summary>
public static Vector128<float> MinMaxScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VADDPD ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Add(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VADDPS ymm1{k1}{z}, ymm2, ymm3/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Add(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VDIVPD ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VDIVPS ymm1{k1}{z}, ymm2, ymm3/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2IBS xmm1{k1}{z}, xmm2/m128/m32bcst</para>
/// </summary>
Expand All @@ -79,11 +59,6 @@ internal Avx10v2() { }
/// </summary>
public static Vector256<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector256<float> value) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2IBS ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<int> ConvertToSByteWithSaturationAndZeroExtendToInt32(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2IUBS xmm1{k1}{z}, xmm2/m128/m32bcst</para>
/// </summary>
Expand All @@ -94,11 +69,6 @@ internal Avx10v2() { }
/// </summary>
public static Vector256<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector256<float> value) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2IUBS ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<int> ConvertToByteWithSaturationAndZeroExtendToInt32(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTTPS2IBS xmm1{k1}{z}, xmm2/m128/m32bcst</para>
/// </summary>
Expand All @@ -119,81 +89,6 @@ internal Avx10v2() { }
/// </summary>
public static Vector256<int> ConvertToByteWithTruncatedSaturationAndZeroExtendToInt32(Vector256<float> value) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTDQ2PS ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> ConvertToVector256Single(Vector256<int> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPD2DQ xmm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector128<int> ConvertToVector128Int32(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPD2PS xmm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector128<float> ConvertToVector128Single(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPD2QQ ymm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<long> ConvertToVector256Int64(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPD2UDQ xmm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector128<uint> ConvertToVector128UInt32(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPD2UQQ ymm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<ulong> ConvertToVector256UInt64(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2DQ ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<int> ConvertToVector256Int32(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2QQ ymm1{k1}{z}, xmm2/m128/m32bcst {er}</para>
/// </summary>
public static Vector256<long> ConvertToVector256Int64(Vector128<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2UDQ ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<uint> ConvertToVector256UInt32(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTPS2UQQ ymm1{k1}{z}, xmm2/m128/m32bcst {er}</para>
/// </summary>
public static Vector256<ulong> ConvertToVector256UInt64(Vector128<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTQQ2PS xmm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector128<float> ConvertToVector128Single(Vector256<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTQQ2PD ymm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> ConvertToVector256Double(Vector256<ulong> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTUDQ2PS ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> ConvertToVector256Single(Vector256<uint> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTUQQ2PS xmm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector128<float> ConvertToVector128Single(Vector256<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VCVTUQQ2PD ymm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> ConvertToVector256Double(Vector256<long> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VMOVD xmm1, xmm2/m32</para>
/// </summary>
Expand All @@ -214,36 +109,6 @@ internal Avx10v2() { }
/// </summary>
public static Vector128<ushort> MoveScalar(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VMULPD ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VMULPS ymm1{k1}{z}, ymm2, ymm3/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSCALEFPD ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Scale(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSCALEFPS ymm1{k1}{z}, ymm2, ymm3/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Scale(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSQRTPD ymm1{k1}{z}, ymm2/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Sqrt(Vector256<double> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSQRTPS ymm1{k1}{z}, ymm2/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Sqrt(Vector256<float> value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VMOVW xmm1/m16, xmm2</para>
/// </summary>
Expand All @@ -254,16 +119,6 @@ internal Avx10v2() { }
/// </summary>
public static unsafe void StoreScalar(ushort* address, Vector128<ushort> source) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSUBPD ymm1{k1}{z}, ymm2, ymm3/m256/m64bcst {er}</para>
/// </summary>
public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>
/// <para> VSUBPS ymm1{k1}{z}, ymm2, ymm3/m256/m32bcst {er}</para>
/// </summary>
public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); }

/// <summary>Provides access to the x86 AVX10.2 hardware instructions, that are only available to 64-bit processes, via intrinsics.</summary>
public new abstract class X64 : Avx10v1.X64
{
Expand Down
Loading
Loading