Wokaround an aliasing bug in GetArrayDataReference

tannergooding · tannergooding · commit 14203ab890d0 · 2022-12-16T09:46:08.000-08:00
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs
@@ -575,7 +575,7 @@ public readonly void CopyTo(float[] array)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);
         }
 
         /// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>
@@ -603,7 +603,7 @@ public readonly void CopyTo(float[] array, int index)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);
         }
 
         /// <summary>Copies the vector to the given <see cref="Span{T}" />.The length of the destination span must be at least 2.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs
@@ -597,7 +597,7 @@ public readonly void CopyTo(float[] array)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);
         }
 
         /// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>
@@ -625,7 +625,7 @@ public readonly void CopyTo(float[] array, int index)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);
         }
 
         /// <summary>Copies the vector to the given <see cref="Span{T}" />. The length of the destination span must be at least 3.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs
@@ -682,7 +682,7 @@ public readonly void CopyTo(float[] array)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);
         }
 
         /// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>
@@ -710,7 +710,7 @@ public readonly void CopyTo(float[] array, int index)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);
         }
 
         /// <summary>Copies the vector to the given <see cref="Span{T}" />. The length of the destination span must be at least 4.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs
@@ -67,7 +67,7 @@ public Vector(T[] values)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));
+            this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[0]));
         }
 
         /// <summary>Creates a new <see cref="Vector{T}" /> from a given array.</summary>
@@ -86,7 +86,7 @@ public Vector(T[] values, int index)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));
+            this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[index]));
         }
 
         /// <summary>Creates a new <see cref="Vector{T}" /> from a given readonly span.</summary>
@@ -666,7 +666,7 @@ public void CopyTo(T[] destination)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), this);
         }
 
         /// <summary>Copies a <see cref="Vector{T}" /> to a given array starting at the specified index.</summary>
@@ -690,7 +690,7 @@ public void CopyTo(T[] destination, int startIndex)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), this);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), this);
         }
 
         /// <summary>Copies a <see cref="Vector{T}" /> to a given span.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -610,7 +610,7 @@ public static void CopyTo<T>(this Vector128<T> vector, T[] destination)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector128{T}" /> to a given array starting at the specified index.</summary>
@@ -638,7 +638,7 @@ public static unsafe void CopyTo<T>(this Vector128<T> vector, T[] destination, i
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector128{T}" /> to a given span.</summary>
@@ -790,7 +790,7 @@ public static Vector128<T> Create<T>(T[] values)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));
+            return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[0]));
         }
 
         /// <summary>Creates a new <see cref="Vector128{T}" /> from a given array.</summary>
@@ -812,7 +812,7 @@ public static Vector128<T> Create<T>(T[] values, int index)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));
+            return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[index]));
         }
 
         /// <summary>Creates a new <see cref="Vector128{T}" /> from a given readonly span.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
@@ -536,7 +536,7 @@ public static void CopyTo<T>(this Vector256<T> vector, T[] destination)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector256{T}" /> to a given array starting at the specified index.</summary>
@@ -564,7 +564,7 @@ public static void CopyTo<T>(this Vector256<T> vector, T[] destination, int star
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector256{T}" /> to a given span.</summary>
@@ -716,7 +716,7 @@ public static Vector256<T> Create<T>(T[] values)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));
+            return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[0]));
         }
 
         /// <summary>Creates a new <see cref="Vector256{T}" /> from a given array.</summary>
@@ -738,7 +738,7 @@ public static Vector256<T> Create<T>(T[] values, int index)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));
+            return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[index]));
         }
 
         /// <summary>Creates a new <see cref="Vector256{T}" /> from a given readonly span.</summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
@@ -476,7 +476,7 @@ public static void CopyTo<T>(this Vector64<T> vector, T[] destination)
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector64{T}" /> to a given array starting at the specified index.</summary>
@@ -504,7 +504,7 @@ public static unsafe void CopyTo<T>(this Vector64<T> vector, T[] destination, in
                 ThrowHelper.ThrowArgumentException_DestinationTooShort();
             }
 
-            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);
+            Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
         }
 
         /// <summary>Copies a <see cref="Vector64{T}" /> to a given span.</summary>
@@ -657,7 +657,7 @@ public static Vector64<T> Create<T>(T[] values)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));
+            return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[0]));
         }
 
         /// <summary>Creates a new <see cref="Vector64{T}" /> from a given array.</summary>
@@ -679,7 +679,7 @@ public static Vector64<T> Create<T>(T[] values, int index)
                 ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
             }
 
-            return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));
+            return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[index]));
         }
 
         /// <summary>Creates a new <see cref="Vector64{T}" /> from a given readonly span.</summary>

Original file line number	Diff line number	Diff line change
`@@ -575,7 +575,7 @@ public readonly void CopyTo(float[] array)`
`575`	`575`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`576`	`576`	`}`
`577`	`577`
`578`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);`
	`578`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);`
`579`	`579`	`}`
`580`	`580`
`581`	`581`	`/// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>`
`@@ -603,7 +603,7 @@ public readonly void CopyTo(float[] array, int index)`
`603`	`603`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`604`	`604`	`}`
`605`	`605`
`606`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);`
	`606`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);`
`607`	`607`	`}`
`608`	`608`
`609`	`609`	`/// <summary>Copies the vector to the given <see cref="Span{T}" />.The length of the destination span must be at least 2.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -597,7 +597,7 @@ public readonly void CopyTo(float[] array)`
`597`	`597`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`598`	`598`	`}`
`599`	`599`
`600`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);`
	`600`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);`
`601`	`601`	`}`
`602`	`602`
`603`	`603`	`/// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>`
`@@ -625,7 +625,7 @@ public readonly void CopyTo(float[] array, int index)`
`625`	`625`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`626`	`626`	`}`
`627`	`627`
`628`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);`
	`628`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);`
`629`	`629`	`}`
`630`	`630`
`631`	`631`	`/// <summary>Copies the vector to the given <see cref="Span{T}" />. The length of the destination span must be at least 3.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -682,7 +682,7 @@ public readonly void CopyTo(float[] array)`
`682`	`682`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`683`	`683`	`}`
`684`	`684`
`685`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetArrayDataReference(array)), this);`
	`685`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);`
`686`	`686`	`}`
`687`	`687`
`688`	`688`	`/// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>`
`@@ -710,7 +710,7 @@ public readonly void CopyTo(float[] array, int index)`
`710`	`710`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`711`	`711`	`}`
`712`	`712`
`713`		`- Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index)), this);`
	`713`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);`
`714`	`714`	`}`
`715`	`715`
`716`	`716`	`/// <summary>Copies the vector to the given <see cref="Span{T}" />. The length of the destination span must be at least 4.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public Vector(T[] values)`
`67`	`67`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`68`	`68`	`}`
`69`	`69`
`70`		`- this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));`
	`70`	`+ this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[0]));`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <summary>Creates a new <see cref="Vector{T}" /> from a given array.</summary>`
`@@ -86,7 +86,7 @@ public Vector(T[] values, int index)`
`86`	`86`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`87`	`87`	`}`
`88`	`88`
`89`		`- this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));`
	`89`	`+ this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[index]));`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`/// <summary>Creates a new <see cref="Vector{T}" /> from a given readonly span.</summary>`
`@@ -666,7 +666,7 @@ public void CopyTo(T[] destination)`
`666`	`666`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`667`	`667`	`}`
`668`	`668`
`669`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), this);`
	`669`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), this);`
`670`	`670`	`}`
`671`	`671`
`672`	`672`	`/// <summary>Copies a <see cref="Vector{T}" /> to a given array starting at the specified index.</summary>`
`@@ -690,7 +690,7 @@ public void CopyTo(T[] destination, int startIndex)`
`690`	`690`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`691`	`691`	`}`
`692`	`692`
`693`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), this);`
	`693`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), this);`
`694`	`694`	`}`
`695`	`695`
`696`	`696`	`/// <summary>Copies a <see cref="Vector{T}" /> to a given span.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -610,7 +610,7 @@ public static void CopyTo<T>(this Vector128<T> vector, T[] destination)`
`610`	`610`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`611`	`611`	`}`
`612`	`612`
`613`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);`
	`613`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);`
`614`	`614`	`}`
`615`	`615`
`616`	`616`	`/// <summary>Copies a <see cref="Vector128{T}" /> to a given array starting at the specified index.</summary>`
`@@ -638,7 +638,7 @@ public static unsafe void CopyTo<T>(this Vector128<T> vector, T[] destination, i`
`638`	`638`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`639`	`639`	`}`
`640`	`640`
`641`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);`
	`641`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);`
`642`	`642`	`}`
`643`	`643`
`644`	`644`	`/// <summary>Copies a <see cref="Vector128{T}" /> to a given span.</summary>`
`@@ -790,7 +790,7 @@ public static Vector128<T> Create<T>(T[] values)`
`790`	`790`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`791`	`791`	`}`
`792`	`792`
`793`		`- return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));`
	`793`	`+ return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[0]));`
`794`	`794`	`}`
`795`	`795`
`796`	`796`	`/// <summary>Creates a new <see cref="Vector128{T}" /> from a given array.</summary>`
`@@ -812,7 +812,7 @@ public static Vector128<T> Create<T>(T[] values, int index)`
`812`	`812`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`813`	`813`	`}`
`814`	`814`
`815`		`- return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));`
	`815`	`+ return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[index]));`
`816`	`816`	`}`
`817`	`817`
`818`	`818`	`/// <summary>Creates a new <see cref="Vector128{T}" /> from a given readonly span.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ public static void CopyTo<T>(this Vector256<T> vector, T[] destination)`
`536`	`536`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`537`	`537`	`}`
`538`	`538`
`539`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);`
	`539`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);`
`540`	`540`	`}`
`541`	`541`
`542`	`542`	`/// <summary>Copies a <see cref="Vector256{T}" /> to a given array starting at the specified index.</summary>`
`@@ -564,7 +564,7 @@ public static void CopyTo<T>(this Vector256<T> vector, T[] destination, int star`
`564`	`564`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`565`	`565`	`}`
`566`	`566`
`567`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);`
	`567`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);`
`568`	`568`	`}`
`569`	`569`
`570`	`570`	`/// <summary>Copies a <see cref="Vector256{T}" /> to a given span.</summary>`
`@@ -716,7 +716,7 @@ public static Vector256<T> Create<T>(T[] values)`
`716`	`716`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`717`	`717`	`}`
`718`	`718`
`719`		`- return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));`
	`719`	`+ return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[0]));`
`720`	`720`	`}`
`721`	`721`
`722`	`722`	`/// <summary>Creates a new <see cref="Vector256{T}" /> from a given array.</summary>`
`@@ -738,7 +738,7 @@ public static Vector256<T> Create<T>(T[] values, int index)`
`738`	`738`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`739`	`739`	`}`
`740`	`740`
`741`		`- return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));`
	`741`	`+ return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[index]));`
`742`	`742`	`}`
`743`	`743`
`744`	`744`	`/// <summary>Creates a new <see cref="Vector256{T}" /> from a given readonly span.</summary>`
Original file line number	Diff line number	Diff line change
`@@ -476,7 +476,7 @@ public static void CopyTo<T>(this Vector64<T> vector, T[] destination)`
`476`	`476`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`477`	`477`	`}`
`478`	`478`
`479`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(destination)), vector);`
	`479`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);`
`480`	`480`	`}`
`481`	`481`
`482`	`482`	`/// <summary>Copies a <see cref="Vector64{T}" /> to a given array starting at the specified index.</summary>`
`@@ -504,7 +504,7 @@ public static unsafe void CopyTo<T>(this Vector64<T> vector, T[] destination, in`
`504`	`504`	`ThrowHelper.ThrowArgumentException_DestinationTooShort();`
`505`	`505`	`}`
`506`	`506`
`507`		`- Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), startIndex)), vector);`
	`507`	`+ Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);`
`508`	`508`	`}`
`509`	`509`
`510`	`510`	`/// <summary>Copies a <see cref="Vector64{T}" /> to a given span.</summary>`
`@@ -657,7 +657,7 @@ public static Vector64<T> Create<T>(T[] values)`
`657`	`657`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`658`	`658`	`}`
`659`	`659`
`660`		`- return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(values)));`
	`660`	`+ return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[0]));`
`661`	`661`	`}`
`662`	`662`
`663`	`663`	`/// <summary>Creates a new <see cref="Vector64{T}" /> from a given array.</summary>`
`@@ -679,7 +679,7 @@ public static Vector64<T> Create<T>(T[] values, int index)`
`679`	`679`	`ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();`
`680`	`680`	`}`
`681`	`681`
`682`		`- return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(values), index)));`
	`682`	`+ return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[index]));`
`683`	`683`	`}`
`684`	`684`
`685`	`685`	`/// <summary>Creates a new <see cref="Vector64{T}" /> from a given readonly span.</summary>`