Improve DangerousGetValueOrNullReference codegen

Author: Sergio0694

CommunityToolkit.HighPerformance/Extensions/NullableExtensions.cs

@@ -53,16 +53,30 @@ public static ref T DangerousGetValueOrDefaultReference<T>(this ref T? value)
     public static unsafe ref T DangerousGetValueOrNullReference<T>(ref this T? value)
         where T : struct
     {
+        ref T resultRef = ref Unsafe.NullRef<T>();
+
+        // This pattern ensures that the resulting code ends up having a single return, and a single
+        // forward branch (the one where the value is null) that is predicted non taken. That is,
+        // the initial null ref is very cheap as it's just clearing a register, and the rest of the
+        // code is a single assignment (lea on x86-64) that should always be taken. This results in:
+        // =============================
+        // L0000: xor eax, eax
+        // L0002: cmp byte ptr[rcx], 0
+        // L0005: je short L000b
+        // L0007: lea rax, [rcx + 4]
+        // L000b: ret
+        // =============================
+        // This is better than what the code would've been with two separate returns in the method.
         if (value.HasValue)
         {
 #if NET7_0_OR_GREATER
-            return ref Unsafe.AsRef(in Nullable.GetValueRefOrDefaultRef(in value));
+            resultRef = ref Unsafe.AsRef(in Nullable.GetValueRefOrDefaultRef(in value));
 #else
-            return ref Unsafe.As<T?, RawNullableData<T>>(ref value).Value;
+            resultRef = ref Unsafe.As<T?, RawNullableData<T>>(ref value).Value;
 #endif
         }
 
-        return ref Unsafe.NullRef<T>();
+        return ref resultRef;
     }
 
 #if !NET7_0_OR_GREATER