Updating Vector256 to have its software fallback be 2x Vector128<T> ops (#76221)

* Updating Vector256<T> to be implemented as 2x Vector128<T> ops

* Updating Vector256 to be implemented as 2x Vector128<T> ops

* Simplify the NRE handling

* A couple of small bug fixes

* Ensure MONO_TYPE_I and MONO_TYPE_U are handled in simd-intrinsics

* Ensure generic paths are handled for SN_CreateScalar and SN_CreateScalarUnsafe

* Ensure nint/nuint are handled in the relevant fallback paths

* Fixing braces to match mono code-styling

* Fixing the "Any" implementation to use `||`

* Fixing Narrow and Widen

* Use Unsafe.ReadUnaligned for the software fallback of Vector256.AsVector()

* Adjust an assert in fgMorphMultiregStructArg to account for certain Unsafe.As reinterprets

Author: tannergooding

src/coreclr/jit/morph.cpp

@@ -3789,9 +3789,19 @@ GenTree* Compiler::fgMorphMultiregStructArg(CallArg* arg)
     ArgElem&       lastElem                 = elems[elemCount - 1];
     assert((elemCount == arg->AbiInfo.NumRegs) || arg->AbiInfo.IsSplit());
 
+    if (layout != nullptr)
+    {
+        assert(ClassLayout::AreCompatible(typGetObjLayout(arg->GetSignatureClassHandle()), layout));
+    }
+    else
+    {
+        assert(varTypeIsSIMD(argValue) && varTypeIsSIMD(arg->GetSignatureType()));
+    }
+
     if (arg->AbiInfo.IsHfaArg() && arg->AbiInfo.IsPassedInFloatRegisters())
     {
         var_types hfaType = arg->AbiInfo.GetHfaType();
+
         for (unsigned inx = 0; inx < elemCount; inx++)
         {
             elems[inx].Type   = hfaType;
@@ -3801,7 +3811,6 @@ GenTree* Compiler::fgMorphMultiregStructArg(CallArg* arg)
     else
     {
         assert(structSize <= MAX_ARG_REG_COUNT * TARGET_POINTER_SIZE);
-        assert((layout != nullptr) || varTypeIsSIMD(argValue));
 
         auto getSlotType = [layout](unsigned inx) {
             return (layout != nullptr) ? layout->GetGCPtrType(inx) : TYP_I_IMPL;
@@ -3974,14 +3983,6 @@ GenTree* Compiler::fgMorphMultiregStructArg(CallArg* arg)
             for (unsigned inx = 0; inx < elemCount; inx++)
             {
                 unsigned offset = lclOffset + elems[inx].Offset;
-#ifdef DEBUG
-                // Make sure we've set up correct GC types above.
-                unsigned  slotIdx   = offset / TARGET_POINTER_SIZE;
-                var_types argGcType = varTypeIsGC(elems[inx].Type) ? elems[inx].Type : TYP_I_IMPL;
-                var_types lclGcType = varDsc->HasGCPtr() ? varDsc->GetLayout()->GetGCPtrType(slotIdx) : TYP_I_IMPL;
-                assert(argGcType == lclGcType);
-#endif // DEBUG
-
                 GenTree* lclFld = gtNewLclFldNode(lclNum, elems[inx].Type, offset);
                 newArg->AddField(this, lclFld, offset, lclFld->TypeGet());
             }

src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs

@@ -105,6 +105,7 @@ public override ValueTypeShapeCharacteristics ComputeValueTypeShapeCharacteristi
                 {
                     8 => ValueTypeShapeCharacteristics.Vector64Aggregate,
                     16 => ValueTypeShapeCharacteristics.Vector128Aggregate,
+                    32 => ValueTypeShapeCharacteristics.Vector128Aggregate,
                     _ => ValueTypeShapeCharacteristics.None
                 };
             }

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs

@@ -60,6 +60,10 @@ public static Vector128<T> Abs<T>(Vector128<T> vector)
             {
                 return vector;
             }
+            else if (typeof(T) == typeof(nuint))
+            {
+                return vector;
+            }
             else if (typeof(T) == typeof(ushort))
             {
                 return vector;
@@ -709,6 +713,14 @@ public static unsafe Vector128<T> Create<T>(T value)
             {
                 return Create((long)(object)value).As<long, T>();
             }
+            else if (typeof(T) == typeof(nint))
+            {
+                return Create((nint)(object)value).As<nint, T>();
+            }
+            else if (typeof(T) == typeof(nuint))
+            {
+                return Create((nuint)(object)value).As<nuint, T>();
+            }
             else if (typeof(T) == typeof(sbyte))
             {
                 return Create((sbyte)(object)value).As<sbyte, T>();
@@ -1538,6 +1550,20 @@ static Vector128<ulong> SoftwareFallback(Vector64<ulong> lower, Vector64<ulong>
             }
         }
 
+        /// <summary>Creates a new <see cref="Vector128{T}" /> instance with the first element initialized to the specified value and the remaining elements initialized to zero.</summary>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <param name="value">The value that element 0 will be initialized to.</param>
+        /// <returns>A new <see cref="Vector128{T}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements initialized to zero.</returns>
+        /// <exception cref="NotSupportedException">The type of <paramref name="value" /> (<typeparamref name="T" />) is not supported.</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe Vector128<T> CreateScalar<T>(T value)
+            where T : struct
+        {
+            Vector128<T> result = Vector128<T>.Zero;
+            result.SetElementUnsafe(0, value);
+            return result;
+        }
+
         /// <summary>Creates a new <see cref="Vector128{Byte}" /> instance with the first element initialized to the specified value and the remaining elements initialized to zero.</summary>
         /// <param name="value">The value that element 0 will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Byte}" /> instance with the first element initialized to <paramref name="value" /> and the remaining elements initialized to zero.</returns>