diff --git a/src/libraries/System.Memory/tests/Span/Fill.cs b/src/libraries/System.Memory/tests/Span/Fill.cs
index 331aefb4b845fd..9118b9980de91a 100644
--- a/src/libraries/System.Memory/tests/Span/Fill.cs
+++ b/src/libraries/System.Memory/tests/Span/Fill.cs
@@ -177,6 +177,7 @@ public static void FillWithRecognizedType()
                 0x1111111111111111, 0x2222222222222222, 0x3333333333333333, 0x4444444444444444,
                 0x5555555555555555, 0x6666666666666666, 0x7777777777777777, 0x8888888888888888)); // 512-bit struct, no SIMD
             RunTest<MyRefContainingStruct>(new("Hello world!")); // struct contains refs, no SIMD
+            RunTest<int?>(42); // nullable type
 
             static void RunTest<T>(T value)
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
index df5427cd075dc4..c29adea608902a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
@@ -29,62 +29,43 @@ public static unsafe void Fill<T>(ref T refData, nuint numElements, T value)
             {
                 // We have enough data for at least one vectorized write.
 
-                T tmp = value; // Avoid taking address of the "value" argument. It would regress performance of the loops below.
                 Vector<byte> vector;
 
                 if (sizeof(T) == 1)
                 {
-                    vector = new Vector<byte>(Unsafe.As<T, byte>(ref tmp));
+                    vector = new Vector<byte>(Unsafe.BitCast<T, byte>(value));
                 }
                 else if (sizeof(T) == 2)
                 {
-                    vector = (Vector<byte>)(new Vector<ushort>(Unsafe.As<T, ushort>(ref tmp)));
+                    vector = (Vector<byte>)new Vector<ushort>(Unsafe.BitCast<T, ushort>(value));
                 }
                 else if (sizeof(T) == 4)
                 {
                     // special-case float since it's already passed in a SIMD reg
                     vector = (typeof(T) == typeof(float))
-                        ? (Vector<byte>)(new Vector<float>((float)(object)tmp!))
-                        : (Vector<byte>)(new Vector<uint>(Unsafe.As<T, uint>(ref tmp)));
+                        ? (Vector<byte>)new Vector<float>(Unsafe.BitCast<T, float>(value))
+                        : (Vector<byte>)new Vector<uint>(Unsafe.BitCast<T, uint>(value));
                 }
                 else if (sizeof(T) == 8)
                 {
                     // special-case double since it's already passed in a SIMD reg
                     vector = (typeof(T) == typeof(double))
-                        ? (Vector<byte>)(new Vector<double>((double)(object)tmp!))
-                        : (Vector<byte>)(new Vector<ulong>(Unsafe.As<T, ulong>(ref tmp)));
+                        ? (Vector<byte>)new Vector<double>(Unsafe.BitCast<T, double>(value))
+                        : (Vector<byte>)new Vector<ulong>(Unsafe.BitCast<T, ulong>(value));
                 }
-                else if (sizeof(T) == 16)
+                else if (sizeof(T) == Vector<byte>.Count)
                 {
-                    Vector128<byte> vec128 = Unsafe.As<T, Vector128<byte>>(ref tmp);
-                    if (Vector<byte>.Count == 16)
-                    {
-                        vector = vec128.AsVector();
-                    }
-                    else if (Vector<byte>.Count == 32)
-                    {
-                        vector = Vector256.Create(vec128).AsVector();
-                    }
-                    else if (Vector<byte>.Count == 64)
-                    {
-                        vector = Vector512.Create(vec128).AsVector();
-                    }
-                    else
-                    {
-                        Debug.Fail("Vector<T> is unexpected size.");
-                        goto CannotVectorize;
-                    }
+                    vector = Unsafe.BitCast<T, Vector<byte>>(value);
                 }
-                else if (sizeof(T) == 32)
+                else if (sizeof(T) == 16)
                 {
-                    Vector256<byte> vec256 = Unsafe.As<T, Vector256<byte>>(ref tmp);
                     if (Vector<byte>.Count == 32)
                     {
-                        vector = vec256.AsVector();
+                        vector = Vector256.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector();
                     }
                     else if (Vector<byte>.Count == 64)
                     {
-                        vector = Vector512.Create(vec256).AsVector();
+                        vector = Vector512.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector();
                     }
                     else
                     {
@@ -92,11 +73,11 @@ public static unsafe void Fill<T>(ref T refData, nuint numElements, T value)
                         goto CannotVectorize;
                     }
                 }
-                else if (sizeof(T) == 64)
+                else if (sizeof(T) == 32)
                 {
                     if (Vector<byte>.Count == 64)
                     {
-                        vector = Unsafe.As<T, Vector512<byte>>(ref tmp).AsVector();
+                        vector = Vector512.Create(Unsafe.BitCast<T, Vector256<byte>>(value)).AsVector();
                     }
                     else
                     {