Replace MemoryMarshal.GetReference with GetReference extension and reuse base addresses (#98)

Copilot · HMBSbige · web-flow · commit beb25ec04086 · 2025-10-27T20:48:16.000+08:00
Co-authored-by: HMBSbige &lt;19153265+HMBSbige@users.noreply.github.com&gt;
Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
diff --git a/src/CryptoBase/FastUtils.cs b/src/CryptoBase/FastUtils.cs
@@ -205,17 +205,17 @@ public static void Xor16(ReadOnlySpan<byte> stream, ReadOnlySpan<byte> source, S
 	{
 		if (Vector128.IsHardwareAccelerated)
 		{
-			ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(stream));
-			ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
-			ref Vector128<byte> dst = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
+			ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref stream.GetReference());
+			ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref source.GetReference());
+			ref Vector128<byte> dst = ref Unsafe.As<byte, Vector128<byte>>(ref destination.GetReference());
 
 			dst = v0 ^ v1;
 		}
 		else
 		{
-			ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(stream));
-			ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(source));
-			ref UInt128 dst = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(destination));
+			ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref stream.GetReference());
+			ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref source.GetReference());
+			ref UInt128 dst = ref Unsafe.As<byte, UInt128>(ref destination.GetReference());
 
 			dst = v0 ^ v1;
 		}
@@ -229,15 +229,15 @@ public static void Xor16(Span<byte> source, ReadOnlySpan<byte> stream)
 	{
 		if (Vector128.IsHardwareAccelerated)
 		{
-			ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));
-			ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(stream));
+			ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref source.GetReference());
+			ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref stream.GetReference());
 
 			v0 ^= v1;
 		}
 		else
 		{
-			ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(source));
-			ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(stream));
+			ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref source.GetReference());
+			ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref stream.GetReference());
 
 			v0 ^= v1;
 		}
diff --git a/src/CryptoBase/Macs/GHash/GHashX86.cs b/src/CryptoBase/Macs/GHash/GHashX86.cs
@@ -18,7 +18,7 @@ public GHashX86(scoped ReadOnlySpan<byte> key)
 	{
 		ArgumentOutOfRangeException.ThrowIfLessThan(key.Length, KeySize, nameof(key));
 
-		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(key));
+		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref key.GetReference());
 		_key = v.ReverseEndianness128();
 
 		Reset();
@@ -28,7 +28,7 @@ public GHashX86(scoped ReadOnlySpan<byte> key)
 	private void GFMul(scoped ReadOnlySpan<byte> x)
 	{
 		Vector128<ulong> a = _key.AsUInt64();
-		Vector128<ulong> b = (Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(x)).ReverseEndianness128() ^ _buffer).AsUInt64();
+		Vector128<ulong> b = (Unsafe.As<byte, Vector128<byte>>(ref x.GetReference()).ReverseEndianness128() ^ _buffer).AsUInt64();
 
 		Vector128<uint> tmp3 = Pclmulqdq.CarrylessMultiply(a, b, 0x00).AsUInt32();
 		Vector128<uint> tmp4 = Pclmulqdq.CarrylessMultiply(a, b, 0x10).AsUInt32();
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamMode.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamMode.cs
@@ -54,7 +54,7 @@ private void UpdateCore(ReadOnlySpan<byte> source, Span<byte> destination)
 			{
 				crypto.Encrypt(counter, stream);
 
-				ref UInt128 c = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(counter));
+				ref UInt128 c = ref Unsafe.As<byte, UInt128>(ref counter.GetReference());
 				c = BinaryPrimitives.ReverseEndianness(BinaryPrimitives.ReverseEndianness(c) + 1);
 			}
 
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock16X86.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock16X86.cs
@@ -35,7 +35,7 @@ public CTR128StreamModeBlock16X86(IBlockCrypto crypto, ReadOnlySpan<byte> iv)
 		_counter = ArrayPool<byte>.Shared.Rent(BlockSize16);
 		_keyStream = ArrayPool<byte>.Shared.Rent(BlockSize16);
 
-		_iCounter = FastUtils.BroadcastVector128ToVector256(ref MemoryMarshal.GetReference(iv)).ReverseEndianness128().IncUpper128Le();
+		_iCounter = FastUtils.BroadcastVector128ToVector256(ref iv.GetReference()).ReverseEndianness128().IncUpper128Le();
 
 		Reset();
 	}
@@ -84,7 +84,7 @@ private void UpdateKeyStream()
 		Vector256<byte> v6 = _counterV6.ReverseEndianness128();
 		Vector256<byte> v7 = _counterV7.ReverseEndianness128();
 
-		ref byte cRef = ref MemoryMarshal.GetReference(c);
+		ref byte cRef = ref c.GetReference();
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 0 * 2 * BlockSize), v0);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 1 * 2 * BlockSize), v1);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 2 * 2 * BlockSize), v2);
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock4X86.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock4X86.cs
@@ -32,7 +32,7 @@ public CTR128StreamModeBlock4X86(IBlockCrypto crypto, ReadOnlySpan<byte> iv)
 		_counter = ArrayPool<byte>.Shared.Rent(BlockSize4);
 		_keyStream = ArrayPool<byte>.Shared.Rent(BlockSize4);
 
-		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(iv));
+		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref iv.GetReference());
 		_iCounter = v.ReverseEndianness128();
 
 		Reset();
@@ -79,7 +79,7 @@ private void UpdateKeyStream()
 		Vector128<byte> v2 = _counterV2.ReverseEndianness128();
 		Vector128<byte> v3 = _counterV3.ReverseEndianness128();
 
-		ref byte cRef = ref MemoryMarshal.GetReference(c);
+		ref byte cRef = ref c.GetReference();
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 0 * BlockSize), v0);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 1 * BlockSize), v1);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 2 * BlockSize), v2);
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock8AvxX86.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock8AvxX86.cs
@@ -32,7 +32,7 @@ public CTR128StreamModeBlock8AvxX86(IBlockCrypto crypto, ReadOnlySpan<byte> iv)
 		_counter = ArrayPool<byte>.Shared.Rent(BlockSize8);
 		_keyStream = ArrayPool<byte>.Shared.Rent(BlockSize8);
 
-		_iCounter = FastUtils.BroadcastVector128ToVector256(ref MemoryMarshal.GetReference(iv)).ReverseEndianness128().IncUpper128Le();
+		_iCounter = FastUtils.BroadcastVector128ToVector256(ref iv.GetReference()).ReverseEndianness128().IncUpper128Le();
 
 		Reset();
 	}
@@ -77,7 +77,7 @@ private void UpdateKeyStream()
 		Vector256<byte> v2 = _counterV2.ReverseEndianness128();
 		Vector256<byte> v3 = _counterV3.ReverseEndianness128();
 
-		ref byte cRef = ref MemoryMarshal.GetReference(c);
+		ref byte cRef = ref c.GetReference();
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 0 * 2 * BlockSize), v0);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 1 * 2 * BlockSize), v1);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 2 * 2 * BlockSize), v2);
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock8X86.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeBlock8X86.cs
@@ -35,7 +35,7 @@ public CTR128StreamModeBlock8X86(IBlockCrypto crypto, ReadOnlySpan<byte> iv)
 		_counter = ArrayPool<byte>.Shared.Rent(BlockSize8);
 		_keyStream = ArrayPool<byte>.Shared.Rent(BlockSize8);
 
-		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(iv));
+		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref iv.GetReference());
 		_iCounter = v.ReverseEndianness128();
 
 		Reset();
@@ -85,7 +85,7 @@ private void UpdateKeyStream()
 		Vector128<byte> v6 = _counterV6.ReverseEndianness128();
 		Vector128<byte> v7 = _counterV7.ReverseEndianness128();
 
-		ref byte cRef = ref MemoryMarshal.GetReference(c);
+		ref byte cRef = ref c.GetReference();
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 0 * BlockSize), v0);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 1 * BlockSize), v1);
 		Unsafe.WriteUnaligned(ref Unsafe.Add(ref cRef, 2 * BlockSize), v2);
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeX86.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/CTR/CTR128StreamModeX86.cs
@@ -22,7 +22,7 @@ public CTR128StreamModeX86(IBlockCrypto crypto, ReadOnlySpan<byte> iv)
 
 		_internalBlockCrypto = crypto;
 
-		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(iv));
+		ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref iv.GetReference());
 		_iCounter = v.ReverseEndianness128();
 
 		Reset();
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/Xts/XtsMode.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptoModes/Xts/XtsMode.cs
@@ -21,7 +21,7 @@ public XtsMode(IBlockCrypto dataCrypto, IBlockCrypto tweakCrypto, ReadOnlySpan<b
 
 		_dataCrypto = dataCrypto;
 		_tweakCrypto = tweakCrypto;
-		_iv = Unsafe.ReadUnaligned<Vector128<byte>>(ref MemoryMarshal.GetReference(iv));
+		_iv = Unsafe.ReadUnaligned<Vector128<byte>>(ref iv.GetReference());
 	}
 
 	[SkipLocalsInit]
diff --git a/src/CryptoBase/SymmetricCryptos/BlockCryptos/SM4/SM4Utils.cs b/src/CryptoBase/SymmetricCryptos/BlockCryptos/SM4/SM4Utils.cs
@@ -201,8 +201,8 @@ public static void Encrypt8(uint[] rk, ReadOnlySpan<byte> source, Span<byte> des
 
 	public static void Encrypt16(uint[] rk, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		ref Vector256<byte> s0 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 0 * 32));
 		ref Vector256<byte> s1 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 1 * 32));
diff --git a/src/CryptoBase/SymmetricCryptos/StreamCryptos/ChaCha20Utils.cs b/src/CryptoBase/SymmetricCryptos/StreamCryptos/ChaCha20Utils.cs
@@ -100,8 +100,8 @@ private static void QuarterRound(ref Vector256<uint> a, ref Vector256<uint> b, r
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void UpdateKeyStream(Span<uint> state, Span<byte> stream, byte rounds)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte streamRef = ref MemoryMarshal.GetReference(stream);
+		ref uint stateRef = ref state.GetReference();
+		ref byte streamRef = ref stream.GetReference();
 
 		ref Vector128<uint> s0 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 0 * 4));
 		ref Vector128<uint> s1 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 1 * 4));
@@ -136,13 +136,13 @@ public static void UpdateKeyStream(Span<uint> state, Span<byte> stream, byte rou
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void IncrementCounterOriginal(Span<uint> state)
 	{
-		++Unsafe.As<uint, ulong>(ref Unsafe.Add(ref MemoryMarshal.GetReference(state), 12));
+		++Unsafe.As<uint, ulong>(ref Unsafe.Add(ref state.GetReference(), 12));
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void IncrementCounter(Span<uint> state)
 	{
-		ref uint counter = ref Unsafe.Add(ref MemoryMarshal.GetReference(state), 12);
+		ref uint counter = ref Unsafe.Add(ref state.GetReference(), 12);
 
 		if (++counter is 0)
 		{
@@ -161,7 +161,7 @@ void Throw()
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void ChaChaRound(Span<uint> state, byte rounds)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
+		ref uint stateRef = ref state.GetReference();
 
 		ref Vector128<uint> x0 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 0 * 4));
 		ref Vector128<uint> x1 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 1 * 4));
@@ -217,9 +217,9 @@ private static void Shuffle1(ref Vector128<uint> a, ref Vector128<uint> b, ref V
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private static void ChaChaCore64Internal(byte rounds, ReadOnlySpan<uint> state, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte destRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte destRef = ref destination.GetReference();
 
 		ref Vector128<uint> s0 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 0 * 4));
 		ref Vector128<uint> s1 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 1 * 4));
@@ -286,9 +286,9 @@ public static void ChaChaCore64(byte rounds, Span<uint> state, ReadOnlySpan<byte
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void ChaChaCoreOriginal128(byte rounds, Span<uint> state, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte destRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte destRef = ref destination.GetReference();
 
 		ref Vector256<byte> src0 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 0 * 32));
 		ref Vector256<byte> src1 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 1 * 32));
@@ -338,9 +338,9 @@ public static void ChaChaCoreOriginal128(byte rounds, Span<uint> state, ReadOnly
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void ChaChaCore128(byte rounds, Span<uint> state, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte destRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte destRef = ref destination.GetReference();
 
 		ref Vector256<byte> src0 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 0 * 32));
 		ref Vector256<byte> src1 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 1 * 32));
@@ -401,9 +401,9 @@ public static int ChaChaCoreOriginal256(byte rounds, Span<uint> state, ReadOnlyS
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		Vector128<uint> o0 = Vector128.Create(Unsafe.Add(ref stateRef, 0));
 		Vector128<uint> o1 = Vector128.Create(Unsafe.Add(ref stateRef, 1));
@@ -489,9 +489,9 @@ public static int ChaChaCore256(byte rounds, Span<uint> state, ReadOnlySpan<byte
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		Vector128<uint> o0 = Vector128.Create(Unsafe.Add(ref stateRef, 0));
 		Vector128<uint> o1 = Vector128.Create(Unsafe.Add(ref stateRef, 1));
@@ -617,9 +617,9 @@ public static int ChaChaCoreOriginal512(byte rounds, Span<uint> state, ReadOnlyS
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		Vector256<uint> o0 = Vector256.Create(Unsafe.Add(ref stateRef, 0));
 		Vector256<uint> o1 = Vector256.Create(Unsafe.Add(ref stateRef, 1));
@@ -740,9 +740,9 @@ public static int ChaChaCore512(byte rounds, Span<uint> state, ReadOnlySpan<byte
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		Vector256<uint> o0 = Vector256.Create(Unsafe.Add(ref stateRef, 0));
 		Vector256<uint> o1 = Vector256.Create(Unsafe.Add(ref stateRef, 1));
diff --git a/src/CryptoBase/SymmetricCryptos/StreamCryptos/Salsa20Crypto.cs b/src/CryptoBase/SymmetricCryptos/StreamCryptos/Salsa20Crypto.cs
@@ -6,6 +6,6 @@ public abstract class Salsa20Crypto : SnuffleCrypto
 
 	protected override void IncrementCounter(Span<uint> state)
 	{
-		++Unsafe.As<uint, ulong>(ref Unsafe.Add(ref MemoryMarshal.GetReference(state), 8));
+		++Unsafe.As<uint, ulong>(ref Unsafe.Add(ref state.GetReference(), 8));
 	}
 }
diff --git a/src/CryptoBase/SymmetricCryptos/StreamCryptos/Salsa20Utils.cs b/src/CryptoBase/SymmetricCryptos/StreamCryptos/Salsa20Utils.cs
@@ -85,8 +85,8 @@ private static void QuarterRound(ref Vector256<uint> a, ref Vector256<uint> b, r
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void UpdateKeyStream(Span<uint> state, Span<byte> stream, byte rounds)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte streamRef = ref MemoryMarshal.GetReference(stream);
+		ref uint stateRef = ref state.GetReference();
+		ref byte streamRef = ref stream.GetReference();
 
 		Vector128<uint> x0 = Vector128.Create(Unsafe.Add(ref stateRef, 4), Unsafe.Add(ref stateRef, 9), Unsafe.Add(ref stateRef, 14), Unsafe.Add(ref stateRef, 3));// 4 9 14 3
 		Vector128<uint> x1 = Vector128.Create(Unsafe.Add(ref stateRef, 0), Unsafe.Add(ref stateRef, 5), Unsafe.Add(ref stateRef, 10), Unsafe.Add(ref stateRef, 15));// 0 5 10 15
@@ -123,7 +123,7 @@ public static void UpdateKeyStream(Span<uint> state, Span<byte> stream, byte rou
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void SalsaRound(Span<uint> state, byte rounds)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
+		ref uint stateRef = ref state.GetReference();
 
 		Vector128<uint> x0 = Vector128.Create(Unsafe.Add(ref stateRef, 4), Unsafe.Add(ref stateRef, 9), Unsafe.Add(ref stateRef, 14), Unsafe.Add(ref stateRef, 3));// 4 9 14 3
 		Vector128<uint> x1 = Vector128.Create(Unsafe.Add(ref stateRef, 0), Unsafe.Add(ref stateRef, 5), Unsafe.Add(ref stateRef, 10), Unsafe.Add(ref stateRef, 15));// 0 5 10 15
@@ -309,9 +309,9 @@ private static void Shuffle(ref Vector256<uint> a, ref Vector256<uint> b, ref Ve
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void SalsaCore64(byte rounds, Span<uint> state, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte destRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte destRef = ref destination.GetReference();
 
 		ref Vector128<uint> s0 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 0 * 4));
 		ref Vector128<uint> s1 = ref Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref stateRef, 1 * 4));
@@ -363,9 +363,9 @@ public static void SalsaCore64(byte rounds, Span<uint> state, ReadOnlySpan<byte>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void SalsaCore128(byte rounds, Span<uint> state, ReadOnlySpan<byte> source, Span<byte> destination)
 	{
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte destRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte destRef = ref destination.GetReference();
 
 		ref Vector256<byte> src0 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 0 * 32));
 		ref Vector256<byte> src1 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 1 * 32));
@@ -461,9 +461,9 @@ public static int SalsaCore256(byte rounds, Span<uint> state, ReadOnlySpan<byte>
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		#region s
 
@@ -563,9 +563,9 @@ public static int SalsaCore512(byte rounds, Span<uint> state, ReadOnlySpan<byte>
 		int length = source.Length;
 		int offset = 0;
 
-		ref uint stateRef = ref MemoryMarshal.GetReference(state);
-		ref byte sourceRef = ref MemoryMarshal.GetReference(source);
-		ref byte dstRef = ref MemoryMarshal.GetReference(destination);
+		ref uint stateRef = ref state.GetReference();
+		ref byte sourceRef = ref source.GetReference();
+		ref byte dstRef = ref destination.GetReference();
 
 		Vector256<uint> o0 = Vector256.Create(Unsafe.Add(ref stateRef, 0));
 		Vector256<uint> o1 = Vector256.Create(Unsafe.Add(ref stateRef, 1));

Original file line number	Diff line number	Diff line change
`@@ -205,17 +205,17 @@ public static void Xor16(ReadOnlySpan<byte> stream, ReadOnlySpan<byte> source, S`
`205`	`205`	`{`
`206`	`206`	`if (Vector128.IsHardwareAccelerated)`
`207`	`207`	`{`
`208`		`- ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(stream));`
`209`		`- ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));`
`210`		`- ref Vector128<byte> dst = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));`
	`208`	`+ ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref stream.GetReference());`
	`209`	`+ ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref source.GetReference());`
	`210`	`+ ref Vector128<byte> dst = ref Unsafe.As<byte, Vector128<byte>>(ref destination.GetReference());`
`211`	`211`
`212`	`212`	`dst = v0 ^ v1;`
`213`	`213`	`}`
`214`	`214`	`else`
`215`	`215`	`{`
`216`		`- ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(stream));`
`217`		`- ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(source));`
`218`		`- ref UInt128 dst = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(destination));`
	`216`	`+ ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref stream.GetReference());`
	`217`	`+ ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref source.GetReference());`
	`218`	`+ ref UInt128 dst = ref Unsafe.As<byte, UInt128>(ref destination.GetReference());`
`219`	`219`
`220`	`220`	`dst = v0 ^ v1;`
`221`	`221`	`}`
`@@ -229,15 +229,15 @@ public static void Xor16(Span<byte> source, ReadOnlySpan<byte> stream)`
`229`	`229`	`{`
`230`	`230`	`if (Vector128.IsHardwareAccelerated)`
`231`	`231`	`{`
`232`		`- ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(source));`
`233`		`- ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(stream));`
	`232`	`+ ref Vector128<byte> v0 = ref Unsafe.As<byte, Vector128<byte>>(ref source.GetReference());`
	`233`	`+ ref Vector128<byte> v1 = ref Unsafe.As<byte, Vector128<byte>>(ref stream.GetReference());`
`234`	`234`
`235`	`235`	`v0 ^= v1;`
`236`	`236`	`}`
`237`	`237`	`else`
`238`	`238`	`{`
`239`		`- ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(source));`
`240`		`- ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(stream));`
	`239`	`+ ref UInt128 v0 = ref Unsafe.As<byte, UInt128>(ref source.GetReference());`
	`240`	`+ ref UInt128 v1 = ref Unsafe.As<byte, UInt128>(ref stream.GetReference());`
`241`	`241`
`242`	`242`	`v0 ^= v1;`
`243`	`243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public GHashX86(scoped ReadOnlySpan<byte> key)`
`18`	`18`	`{`
`19`	`19`	`ArgumentOutOfRangeException.ThrowIfLessThan(key.Length, KeySize, nameof(key));`
`20`	`20`
`21`		`- ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(key));`
	`21`	`+ ref Vector128<byte> v = ref Unsafe.As<byte, Vector128<byte>>(ref key.GetReference());`
`22`	`22`	`_key = v.ReverseEndianness128();`
`23`	`23`
`24`	`24`	`Reset();`
`@@ -28,7 +28,7 @@ public GHashX86(scoped ReadOnlySpan<byte> key)`
`28`	`28`	`private void GFMul(scoped ReadOnlySpan<byte> x)`
`29`	`29`	`{`
`30`	`30`	`Vector128<ulong> a = _key.AsUInt64();`
`31`		`- Vector128<ulong> b = (Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(x)).ReverseEndianness128() ^ _buffer).AsUInt64();`
	`31`	`+ Vector128<ulong> b = (Unsafe.As<byte, Vector128<byte>>(ref x.GetReference()).ReverseEndianness128() ^ _buffer).AsUInt64();`
`32`	`32`
`33`	`33`	`Vector128<uint> tmp3 = Pclmulqdq.CarrylessMultiply(a, b, 0x00).AsUInt32();`
`34`	`34`	`Vector128<uint> tmp4 = Pclmulqdq.CarrylessMultiply(a, b, 0x10).AsUInt32();`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ private void UpdateCore(ReadOnlySpan<byte> source, Span<byte> destination)`
`54`	`54`	`{`
`55`	`55`	`crypto.Encrypt(counter, stream);`
`56`	`56`
`57`		`- ref UInt128 c = ref Unsafe.As<byte, UInt128>(ref MemoryMarshal.GetReference(counter));`
	`57`	`+ ref UInt128 c = ref Unsafe.As<byte, UInt128>(ref counter.GetReference());`
`58`	`58`	`c = BinaryPrimitives.ReverseEndianness(BinaryPrimitives.ReverseEndianness(c) + 1);`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public XtsMode(IBlockCrypto dataCrypto, IBlockCrypto tweakCrypto, ReadOnlySpan<b`
`21`	`21`
`22`	`22`	`_dataCrypto = dataCrypto;`
`23`	`23`	`_tweakCrypto = tweakCrypto;`
`24`		`- _iv = Unsafe.ReadUnaligned<Vector128<byte>>(ref MemoryMarshal.GetReference(iv));`
	`24`	`+ _iv = Unsafe.ReadUnaligned<Vector128<byte>>(ref iv.GetReference());`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`[SkipLocalsInit]`
Original file line number	Diff line number	Diff line change
`@@ -201,8 +201,8 @@ public static void Encrypt8(uint[] rk, ReadOnlySpan<byte> source, Span<byte> des`
`201`	`201`
`202`	`202`	`public static void Encrypt16(uint[] rk, ReadOnlySpan<byte> source, Span<byte> destination)`
`203`	`203`	`{`
`204`		`- ref byte sourceRef = ref MemoryMarshal.GetReference(source);`
`205`		`- ref byte dstRef = ref MemoryMarshal.GetReference(destination);`
	`204`	`+ ref byte sourceRef = ref source.GetReference();`
	`205`	`+ ref byte dstRef = ref destination.GetReference();`
`206`	`206`
`207`	`207`	`ref Vector256<byte> s0 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 0 * 32));`
`208`	`208`	`ref Vector256<byte> s1 = ref Unsafe.As<byte, Vector256<byte>>(ref Unsafe.Add(ref sourceRef, 1 * 32));`