Create a hot path for GetFloatingPointMaxDigitsAndPrecision

Author: tannergooding

src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs

@@ -412,19 +412,48 @@ internal static unsafe void DecimalToNumber(scoped ref decimal d, ref NumberBuff
             number.CheckConsistency();
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int precision, NumberFormatInfo info, out bool isSignificantDigits)
         {
+            // We want to fast path the common case of no format and general format + precision.
+            // These are commonly encountered and the full switch is otherwise large enough to show up in hot path profiles
+
             if (fmt == 0)
             {
                 isSignificantDigits = true;
                 return precision;
             }
 
-            int maxDigits = precision;
+            // Bitwise-or with space (' ') converts any uppercase character to
+            // lowercase and keeps unsupported characters as something unsupported.
+            fmt |= ' ';
 
-            switch (fmt | 0x20)
+            if (fmt == 'g')
             {
-                case 'c':
+                // The general format uses the precision specifier to indicate the number of significant
+                // digits to format. This defaults to the shortest roundtrippable string. Additionally,
+                // given that we can't return zero significant digits, we treat 0 as returning the shortest
+                // roundtrippable string as well.
+
+                isSignificantDigits = true;
+
+                if (precision == 0)
+                {
+                    precision = -1;
+                    return 0;
+                }
+                return precision;
+            }
+
+            return Slow(fmt, ref precision, info, out isSignificantDigits);
+
+            static int Slow(char fmt, ref int precision, NumberFormatInfo info, out bool isSignificantDigits)
+            {
+                int maxDigits = precision;
+
+                switch (fmt)
+                {
+                    case 'c':
                     {
                         // The currency format uses the precision specifier to indicate the number of
                         // decimal digits to format. This defaults to NumberFormatInfo.CurrencyDecimalDigits.
@@ -438,7 +467,7 @@ private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int preci
                         break;
                     }
 
-                case 'e':
+                    case 'e':
                     {
                         // The exponential format uses the precision specifier to indicate the number of
                         // decimal digits to format. This defaults to 6. However, the exponential format
@@ -456,8 +485,8 @@ private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int preci
                         break;
                     }
 
-                case 'f':
-                case 'n':
+                    case 'f':
+                    case 'n':
                     {
                         // The fixed-point and number formats use the precision specifier to indicate the number
                         // of decimal digits to format. This defaults to NumberFormatInfo.NumberDecimalDigits.
@@ -471,23 +500,7 @@ private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int preci
                         break;
                     }
 
-                case 'g':
-                    {
-                        // The general format uses the precision specifier to indicate the number of significant
-                        // digits to format. This defaults to the shortest roundtrippable string. Additionally,
-                        // given that we can't return zero significant digits, we treat 0 as returning the shortest
-                        // roundtrippable string as well.
-
-                        if (precision == 0)
-                        {
-                            precision = -1;
-                        }
-                        isSignificantDigits = true;
-
-                        break;
-                    }
-
-                case 'p':
+                    case 'p':
                     {
                         // The percent format uses the precision specifier to indicate the number of
                         // decimal digits to format. This defaults to NumberFormatInfo.PercentDecimalDigits.
@@ -505,7 +518,7 @@ private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int preci
                         break;
                     }
 
-                case 'r':
+                    case 'r':
                     {
                         // The roundtrip format ignores the precision specifier and always returns the shortest
                         // roundtrippable string.
@@ -516,14 +529,15 @@ private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int preci
                         break;
                     }
 
-                default:
+                    default:
                     {
                         ThrowHelper.ThrowFormatException_BadFormatSpecifier();
                         goto case 'r'; // unreachable
                     }
-            }
+                }
 
-            return maxDigits;
+                return maxDigits;
+            }
         }
 
         public static string FormatFloat<TNumber>(TNumber value, string? format, NumberFormatInfo info)