Respond to PR feedback

Author: tannergooding

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

@@ -928,7 +928,7 @@ public static void Pow10(uint exponent, out BigInteger result)
                 ref BigInteger product = ref temp2;
 
                 exponent >>= 3;
-                uint index = 0;
+                int index = 0;
 
                 while (exponent != 0)
                 {
@@ -938,7 +938,14 @@ public static void Pow10(uint exponent, out BigInteger result)
                         // Multiply into the next temporary
                         unsafe
                         {
-                            ref BigInteger rhs = ref Unsafe.As<uint, BigInteger>(ref Unsafe.AsRef(in Pow10BigNumTable[Pow10BigNumTableIndices[(int)index]]));
+                            // It is safe to reinterpret the memory at the indexed position of Pow10BigNumTable as a BigInteger,
+                            // because Pow10BigNumTable is laid out such that each indexed position contains a valid BigInteger
+                            // representation with the correct structure and alignment.
+
+                            int pow10BigNumTableIndex = Pow10BigNumTableIndices[index];
+                            Debug.Assert((pow10BigNumTableIndex + sizeof(BigInteger)) < Pow10BigNumTable.Length);
+
+                            ref BigInteger rhs = ref Unsafe.As<uint, BigInteger>(ref Unsafe.AsRef(in Pow10BigNumTable[pow10BigNumTableIndex]));
                             Multiply(ref lhs, ref rhs, out product);
                         }
 

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

@@ -77,11 +77,12 @@ private static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitId
 
             // For normalized IEEE floating-point values, each time the exponent is incremented the margin also doubles.
             // That creates a subset of transition numbers where the high margin is twice the size of the low margin.
-            scoped ref BigInteger scaledMarginHigh = ref Unsafe.NullRef<BigInteger>();
             BigInteger optionalMarginHigh;
 
             if (hasUnequalMargins)
             {
+                // The high and low margins are different
+
                 if (exponent > 0)   // We have no fractional component
                 {
                     // 1) Expand the input value by multiplying out the mantissa and exponent.
@@ -118,12 +119,11 @@ private static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitId
                     // scaledMarginHigh = 2 * 2 * 2^(-1)
                     BigInteger.SetUInt32(out optionalMarginHigh, 2);
                 }
-
-                // The high and low margins are different
-                scaledMarginHigh = ref optionalMarginHigh;
             }
             else
             {
+                // The high and low margins are equal
+
                 if (exponent > 0)   // We have no fractional component
                 {
                     // 1) Expand the input value by multiplying out the mantissa and exponent.
@@ -155,10 +155,13 @@ private static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitId
                     BigInteger.SetUInt32(out scaledMarginLow, 1);
                 }
 
-                // The high and low margins are equal
-                scaledMarginHigh = ref scaledMarginLow;
+                // This is unused for this path, but we need it viewed as "initialized" so the
+                // scaledMarginHigh tracking works as expected.
+                Unsafe.SkipInit(out optionalMarginHigh);
             }
 
+            scoped ref BigInteger scaledMarginHigh = ref (hasUnequalMargins ? ref optionalMarginHigh : ref scaledMarginLow);
+
             // Compute an estimate for digitExponent that will be correct or undershoot by one.
             //
             // This optimization is based on the paper "Printing Floating-Point Numbers Quickly and Accurately" by Burger and Dybvig http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.72.4656&rep=rep1&type=pdf

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

@@ -881,7 +881,7 @@ private static ulong ConvertBigIntegerToFloatingPointBits<TFloat>(ref BigInteger
                 hasZeroTail &= (bottomBlock & unusedBottomBlockBitsMask) == 0;
             }
 
-            for (int i = 0; i != bottomBlockIndex; i++)
+            for (int i = 0; i < bottomBlockIndex; i++)
             {
                 hasZeroTail &= (value.GetBlock(i) == 0);
             }