Minor code tweaks

Author: Sergio0694

Microsoft.Toolkit/Diagnostics/Guard.Comparable.Generic.cs

@@ -112,10 +112,7 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
             // so that only the right one will actually be translated into native code.
             if (sizeof(T) == 1)
             {
-                byte valueByte = Unsafe.As<T, byte>(ref value);
-                byte targetByte = Unsafe.As<T, byte>(ref target);
-
-                if (valueByte == targetByte)
+                if (*(byte*)&value == *(byte*)&target)
                 {
                     return;
                 }
@@ -124,10 +121,7 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
             }
             else if (sizeof(T) == 2)
             {
-                ushort valueUShort = Unsafe.As<T, ushort>(ref value);
-                ushort targetUShort = Unsafe.As<T, ushort>(ref target);
-
-                if (valueUShort == targetUShort)
+                if (*(ushort*)&value == *(ushort*)&target)
                 {
                     return;
                 }
@@ -136,10 +130,7 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
             }
             else if (sizeof(T) == 4)
             {
-                uint valueUInt = Unsafe.As<T, uint>(ref value);
-                uint targetUInt = Unsafe.As<T, uint>(ref target);
-
-                if (valueUInt == targetUInt)
+                if (*(uint*)&value == *(uint*)&target)
                 {
                     return;
                 }
@@ -148,10 +139,7 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
             }
             else if (sizeof(T) == 8)
             {
-                ulong valueULong = Unsafe.As<T, ulong>(ref value);
-                ulong targetULong = Unsafe.As<T, ulong>(ref target);
-
-                if (Bit64Compare(ref valueULong, ref targetULong))
+                if (Bit64Compare(*(ulong*)&value, *(ulong*)&target))
                 {
                     return;
                 }
@@ -160,26 +148,20 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
             }
             else if (sizeof(T) == 16)
             {
-                ulong valueULong0 = Unsafe.As<T, ulong>(ref value);
-                ulong targetULong0 = Unsafe.As<T, ulong>(ref target);
+                ulong* p0 = (ulong*)&value;
+                ulong* p1 = (ulong*)&target;
 
-                if (Bit64Compare(ref valueULong0, ref targetULong0))
+                if (Bit64Compare(p0[0], p1[0]) && Bit64Compare(p0[1], p1[1]))
                 {
-                    ulong valueULong1 = Unsafe.Add(ref Unsafe.As<T, ulong>(ref value), 1);
-                    ulong targetULong1 = Unsafe.Add(ref Unsafe.As<T, ulong>(ref target), 1);
-
-                    if (Bit64Compare(ref valueULong1, ref targetULong1))
-                    {
-                        return;
-                    }
+                    return;
                 }
 
                 ThrowHelper.ThrowArgumentExceptionForBitwiseEqualTo(value, target, name);
             }
             else
             {
-                Span<byte> valueBytes = new Span<byte>(Unsafe.AsPointer(ref value), sizeof(T));
-                Span<byte> targetBytes = new Span<byte>(Unsafe.AsPointer(ref target), sizeof(T));
+                Span<byte> valueBytes = new Span<byte>(&value, sizeof(T));
+                Span<byte> targetBytes = new Span<byte>(&target, sizeof(T));
 
                 if (valueBytes.SequenceEqual(targetBytes))
                 {
@@ -193,16 +175,15 @@ public static unsafe void IsBitwiseEqualTo<T>(T value, T target, string name)
         // Compares 64 bits of data from two given memory locations for bitwise equality
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe bool Bit64Compare(ref ulong left, ref ulong right)
+        private static unsafe bool Bit64Compare(ulong left, ulong right)
         {
             // Handles 32 bit case, because using ulong is inefficient
-            if (sizeof(IntPtr) == 4)
+            if (sizeof(nint) == 4)
             {
-                ref int r0 = ref Unsafe.As<ulong, int>(ref left);
-                ref int r1 = ref Unsafe.As<ulong, int>(ref right);
+                uint* p0 = (uint*)&left;
+                uint* p1 = (uint*)&right;
 
-                return r0 == r1 &&
-                       Unsafe.Add(ref r0, 1) == Unsafe.Add(ref r1, 1);
+                return p0[0] == p1[0] && p0[1] == p1[1];
             }
 
             return left == right;