Relaxed GC.AllocateUninitializedArray for ref types as well.

This was done by deferring reference types to GC.AllocateArray to avoid potential memory issues with the GC + uninitialized memory. The API only promises to avoid initialization if possible, anyway.
Refactored tests to parametrically exercise these new relaxed constraints.

src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs

@@ -732,9 +732,6 @@ internal static void UnregisterMemoryLoadChangeNotification(Action notification)
         /// <typeparam name="T">Specifies the type of the array element.</typeparam>
         /// <param name="length">Specifies the length of the array.</param>
         /// <param name="pinned">Specifies whether the allocated array must be pinned.</param>
-        /// <remarks>
-        /// If pinned is set to true, <typeparamref name="T"/> must not be a reference type or a type that contains object references.
-        /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)] // forced to ensure no perf drop for small memory buffers (hot path)
         public static unsafe T[] AllocateUninitializedArray<T>(int length, bool pinned = false) // T[] rather than T?[] to match `new T[length]` behavior
         {
@@ -759,7 +756,7 @@ public static unsafe T[] AllocateUninitializedArray<T>(int length, bool pinned =
             }
             else if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
             {
-                ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
+                return AllocateArray<T>(length, pinned: true);
             }
 
             GC_ALLOC_FLAGS flags = GC_ALLOC_FLAGS.GC_ALLOC_ZEROING_OPTIONAL;

src/coreclr/nativeaot/System.Private.CoreLib/src/System/GC.NativeAot.cs

@@ -795,9 +795,6 @@ internal static ulong GetSegmentSize()
         /// <typeparam name="T">Specifies the type of the array element.</typeparam>
         /// <param name="length">Specifies the length of the array.</param>
         /// <param name="pinned">Specifies whether the allocated array must be pinned.</param>
-        /// <remarks>
-        /// If pinned is set to true, <typeparamref name="T"/> must not be a reference type or a type that contains object references.
-        /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)] // forced to ensure no perf drop for small memory buffers (hot path)
         public static unsafe T[] AllocateUninitializedArray<T>(int length, bool pinned = false)
         {
@@ -821,7 +818,7 @@ public static unsafe T[] AllocateUninitializedArray<T>(int length, bool pinned =
             }
             else if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
             {
-                ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
+                return AllocateArray<T>(length, pinned: true);
             }
 
             // kept outside of the small arrays hot path to have inlining without big size growth

src/libraries/System.Runtime/tests/System/GCTests.cs

@@ -1058,41 +1058,37 @@ private static void AllocateArrayTooLarge()
             Assert.Throws<OutOfMemoryException>(() => GC.AllocateUninitializedArray<double>(int.MaxValue, pinned: true));
         }
 
-        [Fact]
-        private static void AllocateArrayUninitializedPinned_RefType_ThrowsArgumentException()
-        {
-            GC.AllocateUninitializedArray<string>(100);
-            Assert.Throws<ArgumentException>(() => GC.AllocateUninitializedArray<string>(100, pinned: true));
-        }
-
         struct EmbeddedValueType<T>
         {
+            unsafe fixed byte _[7];
             public T Value;
         }
 
-        [Fact]
-        private static void AllocateArrayPinned_ManagedType_DoesNotThrow()
+        [Theory]
+        [InlineData(false), InlineData(true)]
+        private static void AllocateArray_UninitializedOrNot_WithManagedType_DoesNotThrow(bool pinned)
         {
             void TryType<T>()
             {
-                GC.AllocateArray<T>(100);
-                GC.AllocateArray<T>(100, pinned: true);
+                GC.AllocateUninitializedArray<T>(100, pinned);
+                GC.AllocateArray<T>(100, pinned);
 
-                GC.AllocateArray<EmbeddedValueType<T>>(100);
-                GC.AllocateArray<EmbeddedValueType<T>>(100, pinned: true);
+                GC.AllocateArray<EmbeddedValueType<T>>(100, pinned);
+                GC.AllocateUninitializedArray<EmbeddedValueType<T>>(100, pinned);
             }
 
             TryType<string>();
             TryType<object>();
         }
 
-        [Fact]
-        private unsafe static void AllocateArrayPinned_ManagedValueType_CanRoundtripThroughPointer()
+        [Theory]
+        [InlineData(false), InlineData(true)]
+        private unsafe static void AllocateArrayPinned_ManagedValueType_CanRoundtripThroughPointer(bool uninitialized)
         {
             const int k_Length = 100;
             var rng = new Random(0xAF);
 
-            var array = GC.AllocateArray<EmbeddedValueType<string>>(k_Length, pinned: true);
+            var array = uninitialized ? GC.AllocateUninitializedArray<EmbeddedValueType<string>>(k_Length, pinned: true) : GC.AllocateArray<EmbeddedValueType<string>>(k_Length, pinned: true);
             byte* pointer = (byte*)Unsafe.AsPointer(ref array[0]);
             var size = Unsafe.SizeOf<EmbeddedValueType<string>>();