Minor codegen improvements

Author: Sergio0694

Microsoft.Toolkit.HighPerformance/Extensions/BoolExtensions.cs

@@ -23,7 +23,14 @@ public static class BoolExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe byte ToByte(this bool flag)
         {
-            return *(byte*)&flag;
+            // Whenever we need to take the address of an argument, we make a local copy first.
+            // This will be removed by the JIT anyway, but it can help produce better codegen and
+            // remove unwanted stack spills if the caller is using constant arguments. This is
+            // because taking the address of an argument can interfere with some of the flow
+            // analysis executed by the JIT, which can in some cases block constant propagation.
+            bool copy = flag;
+
+            return *(byte*)©
         }
 
         /// <summary>
@@ -58,7 +65,8 @@ public static unsafe int ToInt(this bool flag)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int ToBitwiseMask32(this bool flag)
         {
-            byte rangeFlag = *(byte*)&flag;
+            bool copy = flag;
+            byte rangeFlag = *(byte*)&copy;
             int
                 negativeFlag = rangeFlag - 1,
                 mask = ~negativeFlag;
@@ -77,7 +85,8 @@ public static unsafe int ToBitwiseMask32(this bool flag)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe long ToBitwiseMask64(this bool flag)
         {
-            byte rangeFlag = *(byte*)&flag;
+            bool copy = flag;
+            byte rangeFlag = *(byte*)&copy;
             long
                 negativeFlag = (long)rangeFlag - 1,
                 mask = ~negativeFlag;

Microsoft.Toolkit.HighPerformance/Helpers/BitHelper.cs

@@ -209,8 +209,9 @@ public static unsafe uint SetFlag(uint value, int n, bool flag)
             // and perform an OR with the resulting value of the previous
             // operation. This will always guaranteed to work, thanks to the
             // initial code clearing that bit before setting it again.
+            bool copy = flag;
             uint
-                flag32 = *(byte*)&flag,
+                flag32 = *(byte*)&copy,
                 shift = flag32 << n,
                 or = and | shift;
 
@@ -378,8 +379,9 @@ public static unsafe ulong SetFlag(ulong value, int n, bool flag)
             ulong
                 bit = 1ul << n,
                 not = ~bit,
-                and = value & not,
-                flag64 = *(byte*)&flag,
+                and = value & not;
+            bool copy = flag;
+            ulong flag64 = *(byte*)&copy,
                 shift = flag64 << n,
                 or = and | shift;