Continue tracking the System.Numerics and System.Runtime.Intrinsics APIs as intrinsic for the profitability boost

Author: tannergooding

src/coreclr/jit/importercalls.cpp

@@ -3089,6 +3089,13 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
     }
 #endif // FEATURE_HW_INTRINSICS
 
+    if ((ni == NI_System_Numerics_Intrinsic) || (ni == NI_System_Runtime_Intrinsics_Intrinsic))
+    {
+        // These are special markers used just to ensure we still get the inlining profitability
+        // boost. We actually have the implementation in managed, however, to keep the JIT simpler.
+        return nullptr;
+    }
+
     if (!isIntrinsic)
     {
         // Outside the cases above, there are many intrinsics which apply to only a
@@ -10080,6 +10087,12 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
 
                                 result = NI_Throw_PlatformNotSupportedException;
                             }
+                            else
+                            {
+                                // Otherwise mark this as a general intrinsic in the namespace
+                                // so we can still get the inlining profitability boost.
+                                result = NI_System_Runtime_Intrinsics_Intrinsic;
+                            }
                         }
                     }
                 }
@@ -10304,6 +10317,12 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
 
                                 result = NI_Throw_PlatformNotSupportedException;
                             }
+                            else
+                            {
+                                // Otherwise mark this as a general intrinsic in the namespace
+                                // so we can still get the inlining profitability boost.
+                                result = NI_System_Numerics_Intrinsic;
+                            }
                         }
                     }
                 }

src/coreclr/jit/namedintrinsiclist.h

@@ -140,6 +140,10 @@ enum NamedIntrinsic : unsigned short
     NI_System_Threading_Interlocked_MemoryBarrier,
     NI_System_Threading_Interlocked_ReadMemoryBarrier,
 
+    // These two are special marker IDs so that we still get the inlining profitability boost
+    NI_System_Numerics_Intrinsic,
+    NI_System_Runtime_Intrinsics_Intrinsic,
+
 #ifdef FEATURE_HW_INTRINSICS
     NI_HW_INTRINSIC_START,
 #if defined(TARGET_XARCH)

src/libraries/System.Private.CoreLib/src/System/Numerics/Plane.cs

@@ -27,6 +27,7 @@ public struct Plane : IEquatable<Plane>
         /// <param name="y">The Y component of the normal.</param>
         /// <param name="z">The Z component of the normal.</param>
         /// <param name="d">The distance of the plane along its normal from the origin.</param>
+        [Intrinsic]
         public Plane(float x, float y, float z, float d)
         {
             this = Vector128.Create(x, y, z, d).AsPlane();
@@ -35,13 +36,15 @@ public Plane(float x, float y, float z, float d)
         /// <summary>Creates a <see cref="Plane" /> object from a specified normal and the distance along the normal from the origin.</summary>
         /// <param name="normal">The plane's normal vector.</param>
         /// <param name="d">The plane's distance from the origin along its normal vector.</param>
+        [Intrinsic]
         public Plane(Vector3 normal, float d)
         {
             this = new Vector4(normal, d).AsPlane();
         }
 
         /// <summary>Creates a <see cref="Plane" /> object from a specified four-dimensional vector.</summary>
         /// <param name="value">A vector whose first three elements describe the normal vector, and whose <see cref="Vector4.W" /> defines the distance along that normal from the origin.</param>
+        [Intrinsic]
         public Plane(Vector4 value)
         {
             this = value.AsPlane();
@@ -103,6 +106,7 @@ public static Plane CreateFromVertices(Vector3 point1, Vector3 point2, Vector3 p
         /// <param name="plane">The plane.</param>
         /// <param name="value">The four-dimensional vector.</param>
         /// <returns>The dot product.</returns>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Dot(Plane plane, Vector4 value) => Vector128.Dot(plane.AsVector128(), value.AsVector128());
 
@@ -204,6 +208,7 @@ public static Plane Transform(Plane plane, Quaternion rotation)
         /// <returns><see langword="true" /> if <paramref name="value1" /> and <paramref name="value2" /> are equal; otherwise, <see langword="false" />.</returns>
         /// <remarks>Two <see cref="Plane" /> objects are equal if their <see cref="Normal" /> and <see cref="D" /> fields are equal.
         /// The <see cref="op_Equality" /> method defines the operation of the equality operator for <see cref="Plane" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(Plane value1, Plane value2) => value1.AsVector128() == value2.AsVector128();
 
@@ -212,6 +217,7 @@ public static Plane Transform(Plane plane, Quaternion rotation)
         /// <param name="value2">The second plane to compare.</param>
         /// <returns><see langword="true" /> if <paramref name="value1" /> and <paramref name="value2" /> are not equal; otherwise, <see langword="false" />.</returns>
         /// <remarks>The <see cref="op_Inequality" /> method defines the operation of the inequality operator for <see cref="Plane" /> objects.</remarks>
+        [Intrinsic]
         public static bool operator !=(Plane value1, Plane value2) => !(value1 == value2);
 
         /// <summary>Returns a value that indicates whether this instance and a specified object are equal.</summary>

src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.Extensions.cs

@@ -14,6 +14,7 @@ public static unsafe partial class Vector
         /// <param name="index">The index of the element to get.</param>
         /// <returns>The value of the element at <paramref name="index" />.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="index" /> was less than zero or greater than the number of elements.</exception>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static float GetElement(this Quaternion quaternion, int index)
         {
@@ -26,6 +27,7 @@ internal static float GetElement(this Quaternion quaternion, int index)
         /// <param name="value">The value to set the element to.</param>
         /// <returns>A <see cref="Quaternion" /> with the value of the element at <paramref name="index" /> set to <paramref name="value" /> and the remaining elements set to the same value as that in <paramref name="quaternion" />.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="index" /> was less than zero or greater than the number of elements.</exception>
+        [Intrinsic]
         internal static Quaternion WithElement(this Quaternion quaternion, int index, float value)
         {
             return quaternion.AsVector128().WithElement(index, value).AsQuaternion();

src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.cs

@@ -35,6 +35,7 @@ public struct Quaternion : IEquatable<Quaternion>
         /// <param name="y">The value to assign to the Y component of the quaternion.</param>
         /// <param name="z">The value to assign to the Z component of the quaternion.</param>
         /// <param name="w">The value to assign to the W component of the quaternion.</param>
+        [Intrinsic]
         public Quaternion(float x, float y, float z, float w)
         {
             this = Vector128.Create(x, y, z, w).AsQuaternion();
@@ -43,25 +44,35 @@ public Quaternion(float x, float y, float z, float w)
         /// <summary>Creates a quaternion from the specified vector and rotation parts.</summary>
         /// <param name="vectorPart">The vector part of the quaternion.</param>
         /// <param name="scalarPart">The rotation part of the quaternion.</param>
+        [Intrinsic]
         public Quaternion(Vector3 vectorPart, float scalarPart)
         {
             this = new Vector4(vectorPart, scalarPart).AsQuaternion();
         }
 
         /// <summary>Gets a quaternion that represents a zero.</summary>
         /// <value>A quaternion whose values are <c>(0, 0, 0, 0)</c>.</value>
-        public static Quaternion Zero => default;
+        public static Quaternion Zero
+        {
+            [Intrinsic]
+            get => default;
+        }
 
         /// <summary>Gets a quaternion that represents no rotation.</summary>
         /// <value>A quaternion whose values are <c>(0, 0, 0, 1)</c>.</value>
-        public static Quaternion Identity => new Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
+        public static Quaternion Identity
+        {
+            [Intrinsic]
+            get => new Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
+        }
 
         /// <summary>Gets or sets the element at the specified index.</summary>
         /// <param name="index">The index of the element to get or set.</param>
         /// <returns>The element at <paramref name="index" />.</returns>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="index" /> was less than zero or greater than the number of elements.</exception>
         public float this[int index]
         {
+            [Intrinsic]
             readonly get => this.GetElement(index);
 
             set => this = this.WithElement(index, value);
@@ -77,6 +88,7 @@ public float this[int index]
         /// <param name="value2">The second quaternion.</param>
         /// <returns>The quaternion that contains the summed values of <paramref name="value1" /> and <paramref name="value2" />.</returns>
         /// <remarks>The <see cref="op_Addition" /> method defines the operation of the addition operator for <see cref="Quaternion" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion operator +(Quaternion value1, Quaternion value2) => (value1.AsVector128() + value2.AsVector128()).AsQuaternion();
 
@@ -129,13 +141,15 @@ public float this[int index]
         /// <returns><see langword="true" /> if the two quaternions are equal; otherwise, <see langword="false" />.</returns>
         /// <remarks>Two quaternions are equal if each of their corresponding components is equal.
         /// The <see cref="op_Equality" /> method defines the operation of the equality operator for <see cref="Quaternion" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(Quaternion value1, Quaternion value2) => value1.AsVector128() == value2.AsVector128();
 
         /// <summary>Returns a value that indicates whether two quaternions are not equal.</summary>
         /// <param name="value1">The first quaternion to compare.</param>
         /// <param name="value2">The second quaternion to compare.</param>
         /// <returns><see langword="true" /> if <paramref name="value1" /> and <paramref name="value2" /> are not equal; otherwise, <see langword="false" />.</returns>
+        [Intrinsic]
         public static bool operator !=(Quaternion value1, Quaternion value2) => !(value1 == value2);
 
         /// <summary>Returns the quaternion that results from multiplying two quaternions together.</summary>
@@ -191,6 +205,7 @@ public float this[int index]
         /// <param name="value2">The scalar value.</param>
         /// <returns>The scaled quaternion.</returns>
         /// <remarks>The <see cref="Quaternion.op_Multiply" /> method defines the operation of the multiplication operator for <see cref="Quaternion" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion operator *(Quaternion value1, float value2) => (value1.AsVector128() * value2).AsQuaternion();
 
@@ -199,20 +214,23 @@ public float this[int index]
         /// <param name="value2">The second quaternion.</param>
         /// <returns>The quaternion containing the values that result from subtracting each element in <paramref name="value2" /> from its corresponding element in <paramref name="value1" />.</returns>
         /// <remarks>The <see cref="op_Subtraction" /> method defines the operation of the subtraction operator for <see cref="Quaternion" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion operator -(Quaternion value1, Quaternion value2) => (value1.AsVector128() - value2.AsVector128()).AsQuaternion();
 
         /// <summary>Reverses the sign of each component of the quaternion.</summary>
         /// <param name="value">The quaternion to negate.</param>
         /// <returns>The negated quaternion.</returns>
         /// <remarks>The <see cref="op_UnaryNegation" /> method defines the operation of the unary negation operator for <see cref="Quaternion" /> objects.</remarks>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion operator -(Quaternion value) => (-value.AsVector128()).AsQuaternion();
 
         /// <summary>Adds each element in one quaternion with its corresponding element in a second quaternion.</summary>
         /// <param name="value1">The first quaternion.</param>
         /// <param name="value2">The second quaternion.</param>
         /// <returns>The quaternion that contains the summed values of <paramref name="value1" /> and <paramref name="value2" />.</returns>
+        [Intrinsic]
         public static Quaternion Add(Quaternion value1, Quaternion value2) => value1 + value2;
 
         /// <summary>Concatenates two quaternions.</summary>
@@ -253,6 +271,7 @@ public static Quaternion Concatenate(Quaternion value1, Quaternion value2)
         /// <summary>Returns the conjugate of a specified quaternion.</summary>
         /// <param name="value">The quaternion.</param>
         /// <returns>A new quaternion that is the conjugate of <see langword="value" />.</returns>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion Conjugate(Quaternion value) => (value.AsVector128() * Vector128.Create(-1.0f, -1.0f, -1.0f, 1.0f)).AsQuaternion();
 
@@ -372,12 +391,14 @@ public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float ro
         /// <param name="quaternion1">The first quaternion.</param>
         /// <param name="quaternion2">The second quaternion.</param>
         /// <returns>The dot product.</returns>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Dot(Quaternion quaternion1, Quaternion quaternion2) => Vector128.Dot(quaternion1.AsVector128(), quaternion2.AsVector128());
 
         /// <summary>Returns the inverse of a quaternion.</summary>
         /// <param name="value">The quaternion.</param>
         /// <returns>The inverted quaternion.</returns>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion Inverse(Quaternion value)
         {
@@ -440,16 +461,19 @@ public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, fl
         /// <param name="value1">The source quaternion.</param>
         /// <param name="value2">The scalar value.</param>
         /// <returns>The scaled quaternion.</returns>
+        [Intrinsic]
         public static Quaternion Multiply(Quaternion value1, float value2) => value1 * value2;
 
         /// <summary>Reverses the sign of each component of the quaternion.</summary>
         /// <param name="value">The quaternion to negate.</param>
         /// <returns>The negated quaternion.</returns>
+        [Intrinsic]
         public static Quaternion Negate(Quaternion value) => -value;
 
         /// <summary>Divides each component of a specified <see cref="Quaternion" /> by its length.</summary>
         /// <param name="value">The quaternion to normalize.</param>
         /// <returns>The normalized quaternion.</returns>
+        [Intrinsic]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Quaternion Normalize(Quaternion value) => (value.AsVector128() / value.Length()).AsQuaternion();
 
@@ -506,6 +530,7 @@ public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, f
         /// <param name="value1">The first quaternion.</param>
         /// <param name="value2">The second quaternion.</param>
         /// <returns>The quaternion containing the values that result from subtracting each element in <paramref name="value2" /> from its corresponding element in <paramref name="value1" />.</returns>
+        [Intrinsic]
         public static Quaternion Subtract(Quaternion value1, Quaternion value2) => value1 - value2;
 
         /// <summary>Returns a value that indicates whether this instance and a specified object are equal.</summary>
@@ -527,10 +552,12 @@ public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, f
 
         /// <summary>Calculates the length of the quaternion.</summary>
         /// <returns>The computed length of the quaternion.</returns>
+        [Intrinsic]
         public readonly float Length() => MathF.Sqrt(LengthSquared());
 
         /// <summary>Calculates the squared length of the quaternion.</summary>
         /// <returns>The length squared of the quaternion.</returns>
+        [Intrinsic]
         public readonly float LengthSquared() => Dot(this, this);
 
         /// <summary>Returns a string that represents this quaternion.</summary>