VSadov/Satori
1
0
Fork 0
mirror of https://github.com/VSadov/Satori.git synced 2025-06-09 17:44:48 +09:00
Code Activity

Allow explicitly implemented ISimdVector APIs to be handled as intrinsic (#104983)

Browse source 
* Allow explicitly implemented ISimdVector APIs to be handled as intrinsic

* Apply formatting patch
This commit is contained in:
Tanner Gooding 2024-08-01 09:11:05 -07:00 • committed by GitHub
parent ffacda56ac
commit ae30cbaf99
Signed by: github
GPG key ID: B5690EEEBB952194
9 changed files with 509 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/coreclr/jit/importercalls.cpp
View file

@ -10312,6 +10312,19 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
else
{
#ifdef FEATURE_HW_INTRINSICS
if (strncmp(methodName,
"System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0)
{
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where
// possible but, they all prefix the qualified name of the interface first, so we'll check
// for that and skip the prefix before trying to resolve the method.
if (strncmp(methodName + 70, "<T>,T>.", 7) == 0)
{
methodName += 77;
}
}
CORINFO_SIG_INFO sig;
info.compCompHnd->getMethodSig(method, &sig);
@ -10530,6 +10543,25 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
#error Unsupported platform
#endif
if (strncmp(methodName,
"System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0)
{
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where
// possible but, they all prefix the qualified name of the interface first, so we'll check
// for that and skip the prefix before trying to resolve the method.
if (strncmp(methodName + 70, "64<T>,T>.", 9) == 0)
{
methodName += 79;
}
else if ((strncmp(methodName + 70, "128<T>,T>.", 10) == 0) ||
(strncmp(methodName + 70, "256<T>,T>.", 10) == 0) ||
(strncmp(methodName + 70, "512<T>,T>.", 10) == 0))
{
methodName += 80;
}
}
if ((namespaceName[0] == '\0') || (strcmp(namespaceName, platformNamespaceName) == 0))
{
CORINFO_SIG_INFO sig;

38
src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
View file

@ -4384,12 +4384,44 @@ namespace Internal.JitInterface
// By policy we code review all changes into corelib, such that failing to use an instruction
// set is not a reason to not support usage of it. Except for functions which check if a given
// feature is supported or hardware accelerated.
if (!isMethodDefinedInCoreLib() ||
MethodBeingCompiled.Name == "get_IsSupported" ||
MethodBeingCompiled.Name == "get_IsHardwareAccelerated")
if (!isMethodDefinedInCoreLib())
{
_actualInstructionSetUnsupported.AddInstructionSet(instructionSet);
}
else
{
ReadOnlySpan<char> methodName = MethodBeingCompiled.Name.AsSpan();
if (methodName.StartsWith("System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector"))
{
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
ReadOnlySpan<char> partialMethodName = methodName.Slice(70);
if (partialMethodName.StartsWith("<T>,T>."))
{
methodName = partialMethodName.Slice(7);
}
else if (partialMethodName.StartsWith("64<T>,T>."))
{
methodName = partialMethodName.Slice(9);
}
else if (partialMethodName.StartsWith("128<T>,T>.") ||
partialMethodName.StartsWith("256<T>,T>.") ||
partialMethodName.StartsWith("512<T>,T>."))
{
methodName = partialMethodName.Slice(10);
}
}
if (methodName.Equals("get_IsSupported", StringComparison.Ordinal) ||
methodName.Equals("get_IsHardwareAccelerated", StringComparison.Ordinal))
{
_actualInstructionSetUnsupported.AddInstructionSet(instructionSet);
}
}
}
return supportEnabled;
}

80
src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
View file

@ -825,36 +825,50 @@ namespace System.Numerics
static int ISimdVector<Vector<T>, T>.Alignment => Vector.Alignment;
/// <inheritdoc cref="ISimdVector{TSelf, T}.IsHardwareAccelerated" />
static bool ISimdVector<Vector<T>, T>.IsHardwareAccelerated => Vector.IsHardwareAccelerated;
static bool ISimdVector<Vector<T>, T>.IsHardwareAccelerated
{
[Intrinsic]
get => Vector.IsHardwareAccelerated;
}
/// <inheritdoc cref="ISimdVector{TSelf, T}.Abs(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Abs(Vector<T> vector) => Vector.Abs(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Add(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Add(Vector<T> left, Vector<T> right) => left + right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.AndNot(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.AndNot(Vector<T> left, Vector<T> right) => Vector.AndNot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseAnd(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.BitwiseAnd(Vector<T> left, Vector<T> right) => left & right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseOr(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.BitwiseOr(Vector<T> left, Vector<T> right) => left | right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Ceiling(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Ceiling(Vector<T> vector) => Vector.Ceiling(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Clamp(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Clamp(Vector<T> value, Vector<T> min, Vector<T> max) => Vector.Clamp(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ClampNative(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.ClampNative(Vector<T> value, Vector<T> min, Vector<T> max) => Vector.ClampNative(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ConditionalSelect(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.ConditionalSelect(Vector<T> condition, Vector<T> left, Vector<T> right) => Vector.ConditionalSelect(condition, left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopySign(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.CopySign(Vector<T> value, Vector<T> sign) => Vector.CopySign(value, sign);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopyTo(TSelf, T[])" />
@ -867,6 +881,7 @@ namespace System.Numerics
static void ISimdVector<Vector<T>, T>.CopyTo(Vector<T> vector, Span<T> destination) => vector.CopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Create(T value) => Vector.Create(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T[])" />
@ -879,180 +894,238 @@ namespace System.Numerics
static Vector<T> ISimdVector<Vector<T>, T>.Create(ReadOnlySpan<T> values) => Vector.Create(values);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalar(T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.CreateScalar(T value) => Vector.CreateScalar(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalarUnsafe(T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.CreateScalarUnsafe(T value) => Vector.CreateScalarUnsafe(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Divide(Vector<T> left, Vector<T> right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Divide(Vector<T> left, T right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Dot(TSelf, TSelf)" />
[Intrinsic]
static T ISimdVector<Vector<T>, T>.Dot(Vector<T> left, Vector<T> right) => Vector.Dot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Equals(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Equals(Vector<T> left, Vector<T> right) => Vector.Equals(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.EqualsAll(Vector<T> left, Vector<T> right) => left == right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.EqualsAny(Vector<T> left, Vector<T> right) => Vector.EqualsAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Floor(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Floor(Vector<T> vector) => Vector.Floor(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GetElement(TSelf, int)" />
[Intrinsic]
static T ISimdVector<Vector<T>, T>.GetElement(Vector<T> vector, int index) => vector.GetElement(index);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThan(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.GreaterThan(Vector<T> left, Vector<T> right) => Vector.GreaterThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.GreaterThanAll(Vector<T> left, Vector<T> right) => Vector.GreaterThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.GreaterThanAny(Vector<T> left, Vector<T> right) => Vector.GreaterThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.GreaterThanOrEqual(Vector<T> left, Vector<T> right) => Vector.GreaterThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.GreaterThanOrEqualAll(Vector<T> left, Vector<T> right) => Vector.GreaterThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.GreaterThanOrEqualAny(Vector<T> left, Vector<T> right) => Vector.GreaterThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThan(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LessThan(Vector<T> left, Vector<T> right) => Vector.LessThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.LessThanAll(Vector<T> left, Vector<T> right) => Vector.LessThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.LessThanAny(Vector<T> left, Vector<T> right) => Vector.LessThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LessThanOrEqual(Vector<T> left, Vector<T> right) => Vector.LessThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.LessThanOrEqualAll(Vector<T> left, Vector<T> right) => Vector.LessThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector<T>, T>.LessThanOrEqualAny(Vector<T> left, Vector<T> right) => Vector.LessThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Load(T*)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Load(T* source) => Vector.Load(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAligned(T*)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LoadAligned(T* source) => Vector.LoadAligned(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAlignedNonTemporal(T*)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LoadAlignedNonTemporal(T* source) => Vector.LoadAlignedNonTemporal(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LoadUnsafe(ref readonly T source) => Vector.LoadUnsafe(in source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T, nuint)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector.LoadUnsafe(in source, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Max(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Max(Vector<T> left, Vector<T> right) => Vector.Max(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MaxMagnitude(Vector<T> left, Vector<T> right) => Vector.MaxMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MaxMagnitudeNumber(Vector<T> left, Vector<T> right) => Vector.MaxMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNative(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MaxNative(Vector<T> left, Vector<T> right) => Vector.MaxNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MaxNumber(Vector<T> left, Vector<T> right) => Vector.MaxNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Min(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Min(Vector<T> left, Vector<T> right) => Vector.Min(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MinMagnitude(Vector<T> left, Vector<T> right) => Vector.MinMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MinMagnitudeNumber(Vector<T> left, Vector<T> right) => Vector.MinMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNative(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MinNative(Vector<T> left, Vector<T> right) => Vector.MinNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MinNumber(Vector<T> left, Vector<T> right) => Vector.MinNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Multiply(Vector<T> left, Vector<T> right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Multiply(Vector<T> left, T right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.MultiplyAddEstimate(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.MultiplyAddEstimate(Vector<T> left, Vector<T> right, Vector<T> addend) => Vector.MultiplyAddEstimate(left, right, addend);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Negate(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Negate(Vector<T> vector) => -vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.OnesComplement(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.OnesComplement(Vector<T> vector) => ~vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Round(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Round(Vector<T> vector) => Vector.Round(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftLeft(TSelf, int)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.ShiftLeft(Vector<T> vector, int shiftCount) => vector << shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightArithmetic(TSelf, int)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.ShiftRightArithmetic(Vector<T> vector, int shiftCount) => vector >> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightLogical(TSelf, int)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.ShiftRightLogical(Vector<T> vector, int shiftCount) => vector >>> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sqrt(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Sqrt(Vector<T> vector) => Vector.SquareRoot(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Store(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector<T>, T>.Store(Vector<T> source, T* destination) => source.Store(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAligned(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector<T>, T>.StoreAligned(Vector<T> source, T* destination) => source.StoreAligned(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAlignedNonTemporal(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector<T>, T>.StoreAlignedNonTemporal(Vector<T> source, T* destination) => source.StoreAlignedNonTemporal(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T)" />
[Intrinsic]
static void ISimdVector<Vector<T>, T>.StoreUnsafe(Vector<T> vector, ref T destination) => vector.StoreUnsafe(ref destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T, nuint)" />
[Intrinsic]
static void ISimdVector<Vector<T>, T>.StoreUnsafe(Vector<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Subtract(TSelf, TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Subtract(Vector<T> left, Vector<T> right) => left - right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sum(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector<T>, T>.Sum(Vector<T> vector) => Vector.Sum(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ToScalar(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector<T>, T>.ToScalar(Vector<T> vector) => vector.ToScalar();
/// <inheritdoc cref="ISimdVector{TSelf, T}.Truncate(TSelf)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Truncate(Vector<T> vector) => Vector.Truncate(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.TryCopyTo(TSelf, Span{T})" />
static bool ISimdVector<Vector<T>, T>.TryCopyTo(Vector<T> vector, Span<T> destination) => vector.TryCopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.WithElement(TSelf, int, T)" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.WithElement(Vector<T> vector, int index, T value) => vector.WithElement(index, value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Xor" />
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.Xor(Vector<T> left, Vector<T> right) => left ^ right;
//
@ -1083,14 +1156,19 @@ namespace System.Numerics
}
}
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.IsNaN(Vector<T> vector) => Vector.IsNaN(vector);
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.IsNegative(Vector<T> vector) => Vector.IsNegative(vector);
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.IsPositive(Vector<T> vector) => Vector.IsPositive(vector);
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.IsPositiveInfinity(Vector<T> vector) => Vector.IsPositiveInfinity(vector);
[Intrinsic]
static Vector<T> ISimdVector<Vector<T>, T>.IsZero(Vector<T> vector) => Vector.IsZero(vector);
}
}

80
src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs
View file

@ -472,36 +472,50 @@ namespace System.Runtime.Intrinsics
static int ISimdVector<Vector128<T>, T>.Alignment => Vector128.Alignment;
/// <inheritdoc cref="ISimdVector{TSelf, T}.IsHardwareAccelerated" />
static bool ISimdVector<Vector128<T>, T>.IsHardwareAccelerated => Vector128.IsHardwareAccelerated;
static bool ISimdVector<Vector128<T>, T>.IsHardwareAccelerated
{
[Intrinsic]
get => Vector128.IsHardwareAccelerated;
}
/// <inheritdoc cref="ISimdVector{TSelf, T}.Abs(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Abs(Vector128<T> vector) => Vector128.Abs(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Add(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Add(Vector128<T> left, Vector128<T> right) => left + right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.AndNot(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.AndNot(Vector128<T> left, Vector128<T> right) => Vector128.AndNot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseAnd(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.BitwiseAnd(Vector128<T> left, Vector128<T> right) => left & right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseOr(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.BitwiseOr(Vector128<T> left, Vector128<T> right) => left | right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Ceiling(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Ceiling(Vector128<T> vector) => Vector128.Ceiling(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Clamp(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Clamp(Vector128<T> value, Vector128<T> min, Vector128<T> max) => Vector128.Clamp(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ClampNative(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.ClampNative(Vector128<T> value, Vector128<T> min, Vector128<T> max) => Vector128.ClampNative(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ConditionalSelect(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.ConditionalSelect(Vector128<T> condition, Vector128<T> left, Vector128<T> right) => Vector128.ConditionalSelect(condition, left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopySign(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.CopySign(Vector128<T> value, Vector128<T> sign) => Vector128.CopySign(value, sign);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopyTo(TSelf, T[])" />
@ -514,6 +528,7 @@ namespace System.Runtime.Intrinsics
static void ISimdVector<Vector128<T>, T>.CopyTo(Vector128<T> vector, Span<T> destination) => vector.CopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Create(T value) => Vector128.Create(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T[])" />
@ -526,180 +541,238 @@ namespace System.Runtime.Intrinsics
static Vector128<T> ISimdVector<Vector128<T>, T>.Create(ReadOnlySpan<T> values) => Vector128.Create(values);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalar(T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.CreateScalar(T value) => Vector128.CreateScalar(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalarUnsafe(T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.CreateScalarUnsafe(T value) => Vector128.CreateScalarUnsafe(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Divide(Vector128<T> left, Vector128<T> right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Divide(Vector128<T> left, T right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Dot(TSelf, TSelf)" />
[Intrinsic]
static T ISimdVector<Vector128<T>, T>.Dot(Vector128<T> left, Vector128<T> right) => Vector128.Dot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Equals(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Equals(Vector128<T> left, Vector128<T> right) => Vector128.Equals(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.EqualsAll(Vector128<T> left, Vector128<T> right) => left == right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.EqualsAny(Vector128<T> left, Vector128<T> right) => Vector128.EqualsAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Floor(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Floor(Vector128<T> vector) => Vector128.Floor(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GetElement(TSelf, int)" />
[Intrinsic]
static T ISimdVector<Vector128<T>, T>.GetElement(Vector128<T> vector, int index) => vector.GetElement(index);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThan(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.GreaterThan(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.GreaterThanAll(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.GreaterThanAny(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.GreaterThanOrEqual(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.GreaterThanOrEqualAll(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.GreaterThanOrEqualAny(Vector128<T> left, Vector128<T> right) => Vector128.GreaterThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThan(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LessThan(Vector128<T> left, Vector128<T> right) => Vector128.LessThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.LessThanAll(Vector128<T> left, Vector128<T> right) => Vector128.LessThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.LessThanAny(Vector128<T> left, Vector128<T> right) => Vector128.LessThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LessThanOrEqual(Vector128<T> left, Vector128<T> right) => Vector128.LessThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.LessThanOrEqualAll(Vector128<T> left, Vector128<T> right) => Vector128.LessThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector128<T>, T>.LessThanOrEqualAny(Vector128<T> left, Vector128<T> right) => Vector128.LessThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Load(T*)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Load(T* source) => Vector128.Load(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAligned(T*)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LoadAligned(T* source) => Vector128.LoadAligned(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAlignedNonTemporal(T*)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LoadAlignedNonTemporal(T* source) => Vector128.LoadAlignedNonTemporal(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LoadUnsafe(ref readonly T source) => Vector128.LoadUnsafe(in source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T, nuint)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector128.LoadUnsafe(in source, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Max(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Max(Vector128<T> left, Vector128<T> right) => Vector128.Max(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MaxMagnitude(Vector128<T> left, Vector128<T> right) => Vector128.MaxMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MaxMagnitudeNumber(Vector128<T> left, Vector128<T> right) => Vector128.MaxMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNative(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MaxNative(Vector128<T> left, Vector128<T> right) => Vector128.MaxNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MaxNumber(Vector128<T> left, Vector128<T> right) => Vector128.MaxNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Min(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Min(Vector128<T> left, Vector128<T> right) => Vector128.Min(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MinMagnitude(Vector128<T> left, Vector128<T> right) => Vector128.MinMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MinMagnitudeNumber(Vector128<T> left, Vector128<T> right) => Vector128.MinMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNative(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MinNative(Vector128<T> left, Vector128<T> right) => Vector128.MinNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MinNumber(Vector128<T> left, Vector128<T> right) => Vector128.MinNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Multiply(Vector128<T> left, Vector128<T> right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Multiply(Vector128<T> left, T right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.MultiplyAddEstimate(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.MultiplyAddEstimate(Vector128<T> left, Vector128<T> right, Vector128<T> addend) => Vector128.MultiplyAddEstimate(left, right, addend);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Negate(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Negate(Vector128<T> vector) => -vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.OnesComplement(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.OnesComplement(Vector128<T> vector) => ~vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Round(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Round(Vector128<T> vector) => Vector128.Round(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftLeft(TSelf, int)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.ShiftLeft(Vector128<T> vector, int shiftCount) => vector << shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightArithmetic(TSelf, int)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.ShiftRightArithmetic(Vector128<T> vector, int shiftCount) => vector >> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightLogical(TSelf, int)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.ShiftRightLogical(Vector128<T> vector, int shiftCount) => vector >>> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sqrt(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Sqrt(Vector128<T> vector) => Vector128.Sqrt(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Store(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector128<T>, T>.Store(Vector128<T> source, T* destination) => source.Store(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAligned(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector128<T>, T>.StoreAligned(Vector128<T> source, T* destination) => source.StoreAligned(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAlignedNonTemporal(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector128<T>, T>.StoreAlignedNonTemporal(Vector128<T> source, T* destination) => source.StoreAlignedNonTemporal(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T)" />
[Intrinsic]
static void ISimdVector<Vector128<T>, T>.StoreUnsafe(Vector128<T> vector, ref T destination) => vector.StoreUnsafe(ref destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T, nuint)" />
[Intrinsic]
static void ISimdVector<Vector128<T>, T>.StoreUnsafe(Vector128<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Subtract(TSelf, TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Subtract(Vector128<T> left, Vector128<T> right) => left - right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sum(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector128<T>, T>.Sum(Vector128<T> vector) => Vector128.Sum(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ToScalar(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector128<T>, T>.ToScalar(Vector128<T> vector) => vector.ToScalar();
/// <inheritdoc cref="ISimdVector{TSelf, T}.Truncate(TSelf)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Truncate(Vector128<T> vector) => Vector128.Truncate(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.TryCopyTo(TSelf, Span{T})" />
static bool ISimdVector<Vector128<T>, T>.TryCopyTo(Vector128<T> vector, Span<T> destination) => vector.TryCopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.WithElement(TSelf, int, T)" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.WithElement(Vector128<T> vector, int index, T value) => vector.WithElement(index, value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Xor" />
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.Xor(Vector128<T> left, Vector128<T> right) => left ^ right;
//
@ -716,14 +789,19 @@ namespace System.Runtime.Intrinsics
return 31 - BitOperations.LeadingZeroCount(mask); // 31 = 32 (bits in Int32) - 1 (indexing from zero)
}
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.IsNaN(Vector128<T> vector) => Vector128.IsNaN(vector);
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.IsNegative(Vector128<T> vector) => Vector128.IsNegative(vector);
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.IsPositive(Vector128<T> vector) => Vector128.IsPositive(vector);
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.IsPositiveInfinity(Vector128<T> vector) => Vector128.IsPositiveInfinity(vector);
[Intrinsic]
static Vector128<T> ISimdVector<Vector128<T>, T>.IsZero(Vector128<T> vector) => Vector128.IsZero(vector);
}
}

80
src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs
View file

@ -461,36 +461,50 @@ namespace System.Runtime.Intrinsics
static int ISimdVector<Vector256<T>, T>.Alignment => Vector256.Alignment;
/// <inheritdoc cref="ISimdVector{TSelf, T}.IsHardwareAccelerated" />
static bool ISimdVector<Vector256<T>, T>.IsHardwareAccelerated => Vector256.IsHardwareAccelerated;
static bool ISimdVector<Vector256<T>, T>.IsHardwareAccelerated
{
[Intrinsic]
get => Vector256.IsHardwareAccelerated;
}
/// <inheritdoc cref="ISimdVector{TSelf, T}.Abs(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Abs(Vector256<T> vector) => Vector256.Abs(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Add(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Add(Vector256<T> left, Vector256<T> right) => left + right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.AndNot(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.AndNot(Vector256<T> left, Vector256<T> right) => Vector256.AndNot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseAnd(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.BitwiseAnd(Vector256<T> left, Vector256<T> right) => left & right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseOr(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.BitwiseOr(Vector256<T> left, Vector256<T> right) => left | right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Ceiling(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Ceiling(Vector256<T> vector) => Vector256.Ceiling(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Clamp(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Clamp(Vector256<T> value, Vector256<T> min, Vector256<T> max) => Vector256.Clamp(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ClampNative(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.ClampNative(Vector256<T> value, Vector256<T> min, Vector256<T> max) => Vector256.ClampNative(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ConditionalSelect(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.ConditionalSelect(Vector256<T> condition, Vector256<T> left, Vector256<T> right) => Vector256.ConditionalSelect(condition, left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopySign(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.CopySign(Vector256<T> value, Vector256<T> sign) => Vector256.CopySign(value, sign);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopyTo(TSelf, T[])" />
@ -503,6 +517,7 @@ namespace System.Runtime.Intrinsics
static void ISimdVector<Vector256<T>, T>.CopyTo(Vector256<T> vector, Span<T> destination) => vector.CopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Create(T value) => Vector256.Create(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T[])" />
@ -515,180 +530,238 @@ namespace System.Runtime.Intrinsics
static Vector256<T> ISimdVector<Vector256<T>, T>.Create(ReadOnlySpan<T> values) => Vector256.Create(values);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalar(T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.CreateScalar(T value) => Vector256.CreateScalar(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalarUnsafe(T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.CreateScalarUnsafe(T value) => Vector256.CreateScalarUnsafe(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Divide(Vector256<T> left, Vector256<T> right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Divide(Vector256<T> left, T right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Dot(TSelf, TSelf)" />
[Intrinsic]
static T ISimdVector<Vector256<T>, T>.Dot(Vector256<T> left, Vector256<T> right) => Vector256.Dot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Equals(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Equals(Vector256<T> left, Vector256<T> right) => Vector256.Equals(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.EqualsAll(Vector256<T> left, Vector256<T> right) => left == right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.EqualsAny(Vector256<T> left, Vector256<T> right) => Vector256.EqualsAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Floor(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Floor(Vector256<T> vector) => Vector256.Floor(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GetElement(TSelf, int)" />
[Intrinsic]
static T ISimdVector<Vector256<T>, T>.GetElement(Vector256<T> vector, int index) => vector.GetElement(index);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThan(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.GreaterThan(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.GreaterThanAll(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.GreaterThanAny(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.GreaterThanOrEqual(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.GreaterThanOrEqualAll(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.GreaterThanOrEqualAny(Vector256<T> left, Vector256<T> right) => Vector256.GreaterThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThan(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LessThan(Vector256<T> left, Vector256<T> right) => Vector256.LessThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.LessThanAll(Vector256<T> left, Vector256<T> right) => Vector256.LessThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.LessThanAny(Vector256<T> left, Vector256<T> right) => Vector256.LessThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LessThanOrEqual(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.LessThanOrEqualAll(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector256<T>, T>.LessThanOrEqualAny(Vector256<T> left, Vector256<T> right) => Vector256.LessThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Load(T*)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Load(T* source) => Vector256.Load(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAligned(T*)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LoadAligned(T* source) => Vector256.LoadAligned(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAlignedNonTemporal(T*)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LoadAlignedNonTemporal(T* source) => Vector256.LoadAlignedNonTemporal(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LoadUnsafe(ref readonly T source) => Vector256.LoadUnsafe(in source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T, nuint)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector256.LoadUnsafe(in source, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Max(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Max(Vector256<T> left, Vector256<T> right) => Vector256.Max(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MaxMagnitude(Vector256<T> left, Vector256<T> right) => Vector256.MaxMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MaxMagnitudeNumber(Vector256<T> left, Vector256<T> right) => Vector256.MaxMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNative(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MaxNative(Vector256<T> left, Vector256<T> right) => Vector256.MaxNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MaxNumber(Vector256<T> left, Vector256<T> right) => Vector256.MaxNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Min(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Min(Vector256<T> left, Vector256<T> right) => Vector256.Min(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MinMagnitude(Vector256<T> left, Vector256<T> right) => Vector256.MinMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MinMagnitudeNumber(Vector256<T> left, Vector256<T> right) => Vector256.MinMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNative(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MinNative(Vector256<T> left, Vector256<T> right) => Vector256.MinNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MinNumber(Vector256<T> left, Vector256<T> right) => Vector256.MinNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Multiply(Vector256<T> left, Vector256<T> right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Multiply(Vector256<T> left, T right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.MultiplyAddEstimate(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.MultiplyAddEstimate(Vector256<T> left, Vector256<T> right, Vector256<T> addend) => Vector256.MultiplyAddEstimate(left, right, addend);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Negate(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Negate(Vector256<T> vector) => -vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.OnesComplement(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.OnesComplement(Vector256<T> vector) => ~vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Round(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Round(Vector256<T> vector) => Vector256.Round(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftLeft(TSelf, int)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftLeft(Vector256<T> vector, int shiftCount) => vector << shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightArithmetic(TSelf, int)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftRightArithmetic(Vector256<T> vector, int shiftCount) => vector >> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightLogical(TSelf, int)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.ShiftRightLogical(Vector256<T> vector, int shiftCount) => vector >>> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sqrt(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Sqrt(Vector256<T> vector) => Vector256.Sqrt(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Store(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector256<T>, T>.Store(Vector256<T> source, T* destination) => source.Store(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAligned(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector256<T>, T>.StoreAligned(Vector256<T> source, T* destination) => source.StoreAligned(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAlignedNonTemporal(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector256<T>, T>.StoreAlignedNonTemporal(Vector256<T> source, T* destination) => source.StoreAlignedNonTemporal(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T)" />
[Intrinsic]
static void ISimdVector<Vector256<T>, T>.StoreUnsafe(Vector256<T> vector, ref T destination) => vector.StoreUnsafe(ref destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T, nuint)" />
[Intrinsic]
static void ISimdVector<Vector256<T>, T>.StoreUnsafe(Vector256<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Subtract(TSelf, TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Subtract(Vector256<T> left, Vector256<T> right) => left - right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sum(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector256<T>, T>.Sum(Vector256<T> vector) => Vector256.Sum(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ToScalar(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector256<T>, T>.ToScalar(Vector256<T> vector) => vector.ToScalar();
/// <inheritdoc cref="ISimdVector{TSelf, T}.Truncate(TSelf)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Truncate(Vector256<T> vector) => Vector256.Truncate(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.TryCopyTo(TSelf, Span{T})" />
static bool ISimdVector<Vector256<T>, T>.TryCopyTo(Vector256<T> vector, Span<T> destination) => vector.TryCopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.WithElement(TSelf, int, T)" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.WithElement(Vector256<T> vector, int index, T value) => vector.WithElement(index, value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Xor" />
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.Xor(Vector256<T> left, Vector256<T> right) => left ^ right;
//
@ -705,14 +778,19 @@ namespace System.Runtime.Intrinsics
return 31 - BitOperations.LeadingZeroCount(mask); // 31 = 32 (bits in Int32) - 1 (indexing from zero)
}
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.IsNaN(Vector256<T> vector) => Vector256.IsNaN(vector);
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.IsNegative(Vector256<T> vector) => Vector256.IsNegative(vector);
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.IsPositive(Vector256<T> vector) => Vector256.IsPositive(vector);
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.IsPositiveInfinity(Vector256<T> vector) => Vector256.IsPositiveInfinity(vector);
[Intrinsic]
static Vector256<T> ISimdVector<Vector256<T>, T>.IsZero(Vector256<T> vector) => Vector256.IsZero(vector);
}
}

80
src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs
View file

@ -461,36 +461,50 @@ namespace System.Runtime.Intrinsics
static int ISimdVector<Vector512<T>, T>.Alignment => Vector512.Alignment;
/// <inheritdoc cref="ISimdVector{TSelf, T}.IsHardwareAccelerated" />
static bool ISimdVector<Vector512<T>, T>.IsHardwareAccelerated => Vector512.IsHardwareAccelerated;
static bool ISimdVector<Vector512<T>, T>.IsHardwareAccelerated
{
[Intrinsic]
get => Vector512.IsHardwareAccelerated;
}
/// <inheritdoc cref="ISimdVector{TSelf, T}.Abs(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Abs(Vector512<T> vector) => Vector512.Abs(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Add(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Add(Vector512<T> left, Vector512<T> right) => left + right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.AndNot(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.AndNot(Vector512<T> left, Vector512<T> right) => Vector512.AndNot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseAnd(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseAnd(Vector512<T> left, Vector512<T> right) => left & right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.BitwiseOr(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.BitwiseOr(Vector512<T> left, Vector512<T> right) => left | right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Ceiling(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Ceiling(Vector512<T> vector) => Vector512.Ceiling(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Clamp(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Clamp(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.Clamp(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ClampNative(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.ClampNative(Vector512<T> value, Vector512<T> min, Vector512<T> max) => Vector512.ClampNative(value, min, max);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ConditionalSelect(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.ConditionalSelect(Vector512<T> condition, Vector512<T> left, Vector512<T> right) => Vector512.ConditionalSelect(condition, left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopySign(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.CopySign(Vector512<T> value, Vector512<T> sign) => Vector512.CopySign(value, sign);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CopyTo(TSelf, T[])" />
@ -503,6 +517,7 @@ namespace System.Runtime.Intrinsics
static void ISimdVector<Vector512<T>, T>.CopyTo(Vector512<T> vector, Span<T> destination) => vector.CopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Create(T value) => Vector512.Create(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Create(T[])" />
@ -515,180 +530,238 @@ namespace System.Runtime.Intrinsics
static Vector512<T> ISimdVector<Vector512<T>, T>.Create(ReadOnlySpan<T> values) => Vector512.Create(values);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalar(T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalar(T value) => Vector512.CreateScalar(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.CreateScalarUnsafe(T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.CreateScalarUnsafe(T value) => Vector512.CreateScalarUnsafe(value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, Vector512<T> right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Divide(TSelf, T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Divide(Vector512<T> left, T right) => left / right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Dot(TSelf, TSelf)" />
[Intrinsic]
static T ISimdVector<Vector512<T>, T>.Dot(Vector512<T> left, Vector512<T> right) => Vector512.Dot(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Equals(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Equals(Vector512<T> left, Vector512<T> right) => Vector512.Equals(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.EqualsAll(Vector512<T> left, Vector512<T> right) => left == right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.EqualsAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.EqualsAny(Vector512<T> left, Vector512<T> right) => Vector512.EqualsAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Floor(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Floor(Vector512<T> vector) => Vector512.Floor(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GetElement(TSelf, int)" />
[Intrinsic]
static T ISimdVector<Vector512<T>, T>.GetElement(Vector512<T> vector, int index) => vector.GetElement(index);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThan(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThan(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.GreaterThanAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.GreaterThanAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.GreaterThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.GreaterThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.GreaterThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.GreaterThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThan(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LessThan(Vector512<T> left, Vector512<T> right) => Vector512.LessThan(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.LessThanAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.LessThanAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqual(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LessThanOrEqual(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqual(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAll(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAll(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAll(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LessThanOrEqualAny(TSelf, TSelf)" />
[Intrinsic]
static bool ISimdVector<Vector512<T>, T>.LessThanOrEqualAny(Vector512<T> left, Vector512<T> right) => Vector512.LessThanOrEqualAny(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Load(T*)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Load(T* source) => Vector512.Load(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAligned(T*)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAligned(T* source) => Vector512.LoadAligned(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadAlignedNonTemporal(T*)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LoadAlignedNonTemporal(T* source) => Vector512.LoadAlignedNonTemporal(source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source) => Vector512.LoadUnsafe(in source);
/// <inheritdoc cref="ISimdVector{TSelf, T}.LoadUnsafe(ref readonly T, nuint)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.LoadUnsafe(ref readonly T source, nuint elementOffset) => Vector512.LoadUnsafe(in source, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Max(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Max(Vector512<T> left, Vector512<T> right) => Vector512.Max(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MaxMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNative(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNative(Vector512<T> left, Vector512<T> right) => Vector512.MaxNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MaxNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MaxNumber(Vector512<T> left, Vector512<T> right) => Vector512.MaxNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Min(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Min(Vector512<T> left, Vector512<T> right) => Vector512.Min(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitude(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitude(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitude(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinMagnitudeNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MinMagnitudeNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinMagnitudeNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNative(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MinNative(Vector512<T> left, Vector512<T> right) => Vector512.MinNative(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.MinNumber(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MinNumber(Vector512<T> left, Vector512<T> right) => Vector512.MinNumber(left, right);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, Vector512<T> right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Multiply(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Multiply(Vector512<T> left, T right) => left * right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.MultiplyAddEstimate(TSelf, TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.MultiplyAddEstimate(Vector512<T> left, Vector512<T> right, Vector512<T> addend) => Vector512.MultiplyAddEstimate(left, right, addend);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Negate(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Negate(Vector512<T> vector) => -vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.OnesComplement(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.OnesComplement(Vector512<T> vector) => ~vector;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Round(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Round(Vector512<T> vector) => Vector512.Round(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftLeft(TSelf, int)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftLeft(Vector512<T> vector, int shiftCount) => vector << shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightArithmetic(TSelf, int)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightArithmetic(Vector512<T> vector, int shiftCount) => vector >> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.ShiftRightLogical(TSelf, int)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.ShiftRightLogical(Vector512<T> vector, int shiftCount) => vector >>> shiftCount;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sqrt(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Sqrt(Vector512<T> vector) => Vector512.Sqrt(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Store(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector512<T>, T>.Store(Vector512<T> source, T* destination) => source.Store(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAligned(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector512<T>, T>.StoreAligned(Vector512<T> source, T* destination) => source.StoreAligned(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreAlignedNonTemporal(TSelf, T*)" />
[Intrinsic]
static void ISimdVector<Vector512<T>, T>.StoreAlignedNonTemporal(Vector512<T> source, T* destination) => source.StoreAlignedNonTemporal(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T)" />
[Intrinsic]
static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination) => vector.StoreUnsafe(ref destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.StoreUnsafe(TSelf, ref T, nuint)" />
[Intrinsic]
static void ISimdVector<Vector512<T>, T>.StoreUnsafe(Vector512<T> vector, ref T destination, nuint elementOffset) => vector.StoreUnsafe(ref destination, elementOffset);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Subtract(TSelf, TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Subtract(Vector512<T> left, Vector512<T> right) => left - right;
/// <inheritdoc cref="ISimdVector{TSelf, T}.Sum(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector512<T>, T>.Sum(Vector512<T> vector) => Vector512.Sum(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.ToScalar(TSelf)" />
[Intrinsic]
static T ISimdVector<Vector512<T>, T>.ToScalar(Vector512<T> vector) => vector.ToScalar();
/// <inheritdoc cref="ISimdVector{TSelf, T}.Truncate(TSelf)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Truncate(Vector512<T> vector) => Vector512.Truncate(vector);
/// <inheritdoc cref="ISimdVector{TSelf, T}.TryCopyTo(TSelf, Span{T})" />
static bool ISimdVector<Vector512<T>, T>.TryCopyTo(Vector512<T> vector, Span<T> destination) => vector.TryCopyTo(destination);
/// <inheritdoc cref="ISimdVector{TSelf, T}.WithElement(TSelf, int, T)" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.WithElement(Vector512<T> vector, int index, T value) => vector.WithElement(index, value);
/// <inheritdoc cref="ISimdVector{TSelf, T}.Xor" />
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.Xor(Vector512<T> left, Vector512<T> right) => left ^ right;
//
@ -705,14 +778,19 @@ namespace System.Runtime.Intrinsics
return 63 - BitOperations.LeadingZeroCount(mask); // 63 = 64 (bits in Int64) - 1 (indexing from zero)
}
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.IsNaN(Vector512<T> vector) => Vector512.IsNaN(vector);
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.IsNegative(Vector512<T> vector) => Vector512.IsNegative(vector);
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositive(Vector512<T> vector) => Vector512.IsPositive(vector);
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.IsPositiveInfinity(Vector512<T> vector) => Vector512.IsPositiveInfinity(vector);
[Intrinsic]
static Vector512<T> ISimdVector<Vector512<T>, T>.IsZero(Vector512<T> vector) => Vector512.IsZero(vector);
}
}

61
src/mono/mono/mini/interp/transform-simd.c
View file

@ -42,9 +42,9 @@ simd_intrinsic_compare_by_name (const void *key, const void *value)
}
static int
lookup_intrins (guint16 *intrinsics, int size, MonoMethod *cmethod)
lookup_intrins (guint16 *intrinsics, int size, const char *cmethod_name)
{
guint16 *result = mono_binary_search (cmethod->name, intrinsics, size / sizeof (guint16), sizeof (guint16), &simd_intrinsic_compare_by_name);
guint16 *result = mono_binary_search (cmethod_name, intrinsics, size / sizeof (guint16), sizeof (guint16), &simd_intrinsic_compare_by_name);
if (result == NULL)
return -1;
@ -414,7 +414,19 @@ emit_vector_create (TransformData *td, MonoMethodSignature *csignature, MonoClas
static gboolean
emit_sri_vector128 (TransformData *td, MonoMethod *cmethod, MonoMethodSignature *csignature)
{
int id = lookup_intrins (sri_vector128_methods, sizeof (sri_vector128_methods), cmethod);
const char *cmethod_name = cmethod->name;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if (strncmp(cmethod_name + 70, "128<T>,T>.", 10) == 0) {
cmethod_name += 80;
}
}
int id = lookup_intrins (sri_vector128_methods, sizeof (sri_vector128_methods), cmethod_name);
if (id == -1)
return FALSE;
@ -614,9 +626,28 @@ opcode_added:
static gboolean
emit_sri_vector128_t (TransformData *td, MonoMethod *cmethod, MonoMethodSignature *csignature)
{
int id = lookup_intrins (sri_vector128_t_methods, sizeof (sri_vector128_t_methods), cmethod);
if (id == -1)
return FALSE;
const char *cmethod_name = cmethod->name;
bool explicitly_implemented = false;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if ((strncmp(cmethod_name + 70, "128<T>,T>.", 10) == 0)) {
cmethod_name += 80;
explicitly_implemented = true;
}
}
int id = lookup_intrins (sri_vector128_t_methods, sizeof (sri_vector128_t_methods), cmethod->name);
if (id == -1) {
if (explicitly_implemented) {
return emit_sri_vector128 (td, cmethod, csignature);
} else {
return FALSE;
}
}
gint16 simd_opcode = -1;
gint16 simd_intrins = -1;
@ -646,7 +677,19 @@ opcode_added:
static gboolean
emit_sn_vector_t (TransformData *td, MonoMethod *cmethod, MonoMethodSignature *csignature, gboolean newobj)
{
int id = lookup_intrins (sn_vector_t_methods, sizeof (sn_vector_t_methods), cmethod);
const char *cmethod_name = cmethod->name;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if (strncmp(cmethod_name + 70, "<T>,T>.", 7) == 0) {
cmethod_name += 77;
}
}
int id = lookup_intrins (sn_vector_t_methods, sizeof (sn_vector_t_methods), cmethod_name);
if (id == -1)
return FALSE;
@ -691,7 +734,7 @@ opcode_added:
static gboolean
emit_sn_vector4 (TransformData *td, MonoMethod *cmethod, MonoMethodSignature *csignature, gboolean newobj)
{
int id = lookup_intrins (sn_vector_t_methods, sizeof (sn_vector_t_methods), cmethod);
int id = lookup_intrins (sn_vector_t_methods, sizeof (sn_vector_t_methods), cmethod->name);
if (id == -1)
return FALSE;
@ -943,7 +986,7 @@ lookup_packedsimd_intrinsic (const char *name, MonoType *arg1)
static gboolean
emit_sri_packedsimd (TransformData *td, MonoMethod *cmethod, MonoMethodSignature *csignature)
{
int id = lookup_intrins (sri_packedsimd_methods, sizeof (sri_packedsimd_methods), cmethod);
int id = lookup_intrins (sri_packedsimd_methods, sizeof (sri_packedsimd_methods), cmethod->name);
// We don't early-out for an unrecognized method, we will generate an NIY later
MonoClass *vector_klass = mono_class_from_mono_type_internal (csignature->ret);

20
src/mono/mono/mini/intrinsics.c
View file

@ -2272,7 +2272,25 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
if (in_corlib &&
((!strcmp ("System.Numerics", cmethod_klass_name_space) && !strcmp ("Vector", cmethod_klass_name)) ||
!strncmp ("System.Runtime.Intrinsics", cmethod_klass_name_space, 25))) {
if (!strcmp (cmethod->name, "get_IsHardwareAccelerated")) {
const char* cmethod_name = cmethod->name;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if (strncmp(cmethod_name + 70, "<T>,T>.", 7) == 0) {
cmethod_name += 77;
} else if (strncmp(cmethod_name + 70, "64<T>,T>.", 9) == 0) {
cmethod_name += 79;
} else if ((strncmp(cmethod_name + 70, "128<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "256<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "512<T>,T>.", 10) == 0)) {
cmethod_name += 80;
}
}
if (!strcmp (cmethod_name, "get_IsHardwareAccelerated")) {
EMIT_NEW_ICONST (cfg, ins, 0);
ins->type = STACK_I4;
return ins;

66
src/mono/mono/mini/simd-intrinsics.c
View file

@ -138,9 +138,9 @@ simd_intrinsic_info_compare_by_name (const void *key, const void *value)
}
static int
lookup_intrins (guint16 *intrinsics, int size, MonoMethod *cmethod)
lookup_intrins (guint16 *intrinsics, int size, const char *cmethod_name)
{
const guint16 *result = (const guint16 *)mono_binary_search (cmethod->name, intrinsics, size / sizeof (guint16), sizeof (guint16), &simd_intrinsic_compare_by_name);
const guint16 *result = (const guint16 *)mono_binary_search (cmethod_name, intrinsics, size / sizeof (guint16), sizeof (guint16), &simd_intrinsic_compare_by_name);
if (result == NULL)
return -1;
@ -149,7 +149,7 @@ lookup_intrins (guint16 *intrinsics, int size, MonoMethod *cmethod)
}
static SimdIntrinsic*
lookup_intrins_info (SimdIntrinsic *intrinsics, int size, MonoMethod *cmethod)
lookup_intrins_info (SimdIntrinsic *intrinsics, int size, const char *cmethod_name)
{
#if 0
for (int i = 0; i < (size / sizeof (SimdIntrinsic)) - 1; ++i) {
@ -167,7 +167,7 @@ lookup_intrins_info (SimdIntrinsic *intrinsics, int size, MonoMethod *cmethod)
}
}
#endif
return (SimdIntrinsic *)mono_binary_search (cmethod->name, intrinsics, size / sizeof (SimdIntrinsic), sizeof (SimdIntrinsic), &simd_intrinsic_info_compare_by_name);
return (SimdIntrinsic *)mono_binary_search (cmethod_name, intrinsics, size / sizeof (SimdIntrinsic), sizeof (SimdIntrinsic), &simd_intrinsic_info_compare_by_name);
}
static gboolean
@ -1074,7 +1074,7 @@ emit_hardware_intrinsics (
const SimdIntrinsic *intrinsics = intrin_group->intrinsics;
int intrinsics_size = intrin_group->intrinsics_size;
MonoCPUFeatures feature = intrin_group->feature;
const SimdIntrinsic *info = lookup_intrins_info ((SimdIntrinsic *) intrinsics, intrinsics_size, cmethod);
const SimdIntrinsic *info = lookup_intrins_info ((SimdIntrinsic *) intrinsics, intrinsics_size, cmethod->name);
{
if (!info)
goto support_probe_complete;
@ -1922,7 +1922,25 @@ emit_dot (MonoCompile *cfg, MonoClass *klass, MonoType *vector_type, MonoTypeEnu
static MonoInst*
emit_sri_vector (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
int id = lookup_intrins (sri_vector_methods, sizeof (sri_vector_methods), cmethod);
const char *cmethod_name = cmethod->name;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if (strncmp(cmethod_name + 70, "<T>,T>.", 7) == 0) {
cmethod_name += 77;
} else if (strncmp(cmethod_name + 70, "64<T>,T>.", 9) == 0) {
cmethod_name += 79;
} else if ((strncmp(cmethod_name + 70, "128<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "256<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "512<T>,T>.", 10) == 0)) {
cmethod_name += 80;
}
}
int id = lookup_intrins (sri_vector_methods, sizeof (sri_vector_methods), cmethod_name);
if (id == -1) {
//check_no_intrinsic_cattr (cmethod);
return NULL;
@ -3169,10 +3187,36 @@ static guint16 sri_vector_t_methods [] = {
static MonoInst*
emit_sri_vector_t (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
int id = lookup_intrins (sri_vector_t_methods, sizeof (sri_vector_t_methods), cmethod);
const char *cmethod_name = cmethod->name;
bool explicitly_implemented = false;
if (strncmp(cmethod_name, "System.Runtime.Intrinsics.ISimdVector<System.Runtime.Intrinsics.Vector", 70) == 0) {
// We want explicitly implemented ISimdVector<TSelf, T> APIs to still be expanded where possible
// but, they all prefix the qualified name of the interface first, so we'll check for that and
// skip the prefix before trying to resolve the method.
if (strncmp(cmethod_name + 70, "<T>,T>.", 7) == 0) {
cmethod_name += 77;
explicitly_implemented = true;
} else if (strncmp(cmethod_name + 70, "64<T>,T>.", 9) == 0) {
cmethod_name += 79;
explicitly_implemented = true;
} else if ((strncmp(cmethod_name + 70, "128<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "256<T>,T>.", 10) == 0) ||
(strncmp(cmethod_name + 70, "512<T>,T>.", 10) == 0)) {
cmethod_name += 80;
explicitly_implemented = true;
}
}
int id = lookup_intrins (sri_vector_t_methods, sizeof (sri_vector_t_methods), cmethod_name);
if (id == -1) {
//check_no_intrinsic_cattr (cmethod);
return NULL;
if (explicitly_implemented) {
return emit_sri_vector (cfg, cmethod, fsig, args);
} else {
//check_no_intrinsic_cattr (cmethod);
return NULL;
}
}
MonoClass *klass = cmethod->klass;
@ -3430,7 +3474,7 @@ emit_vector_2_3_4 (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *f
MonoClass *klass;
MonoType *type, *etype;
id = lookup_intrins (vector_2_3_4_methods, sizeof (vector_2_3_4_methods), cmethod);
id = lookup_intrins (vector_2_3_4_methods, sizeof (vector_2_3_4_methods), cmethod->name);
if (id == -1) {
// https://github.com/dotnet/runtime/issues/81961
// check_no_intrinsic_cattr (cmethod);
@ -5982,7 +6026,7 @@ emit_wasm_zero_count (MonoCompile *cfg, MonoMethodSignature *fsig, MonoInst **ar
static MonoInst*
emit_wasm_bitoperations_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
int id = lookup_intrins (bitoperations_methods, sizeof (bitoperations_methods), cmethod);
int id = lookup_intrins (bitoperations_methods, sizeof (bitoperations_methods), cmethod->name);
if (id == -1) {
return NULL;
}