Revert whitespace fixes to third_party (#501)

third_party/compiler_rt/absvdi2.c

@@ -14,7 +14,7 @@
  */
 
 STATIC_YOINK("huge_compiler_rt_license");
-
+ 
 #include "third_party/compiler_rt/int_lib.h"
 
 /* Returns: absolute value */

third_party/compiler_rt/absvsi2.c

@@ -14,7 +14,7 @@
  */
 
 STATIC_YOINK("huge_compiler_rt_license");
-
+ 
 #include "third_party/compiler_rt/int_lib.h"
 
 /* Returns: absolute value */

third_party/compiler_rt/comparedf2.c

@@ -52,18 +52,18 @@ enum LE_RESULT {
 
 COMPILER_RT_ABI enum LE_RESULT
 __ledf2(fp_t a, fp_t b) {
-
+    
     const srep_t aInt = toRep(a);
     const srep_t bInt = toRep(b);
     const rep_t aAbs = aInt & absMask;
     const rep_t bAbs = bInt & absMask;
-
+    
     // If either a or b is NaN, they are unordered.
     if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
-
+    
     // If a and b are both zeros, they are equal.
     if ((aAbs | bAbs) == 0) return LE_EQUAL;
-
+    
     // If at least one of a and b is positive, we get the same result comparing
     // a and b as signed integers as we would with a floating-point compare.
     if ((aInt & bInt) >= 0) {
@@ -71,7 +71,7 @@ __ledf2(fp_t a, fp_t b) {
         else if (aInt == bInt) return LE_EQUAL;
         else return LE_GREATER;
     }
-
+    
     // Otherwise, both are negative, so we need to flip the sense of the
     // comparison to get the correct result.  (This assumes a twos- or ones-
     // complement integer representation; if integers are represented in a
@@ -98,12 +98,12 @@ enum GE_RESULT {
 
 COMPILER_RT_ABI enum GE_RESULT
 __gedf2(fp_t a, fp_t b) {
-
+    
     const srep_t aInt = toRep(a);
     const srep_t bInt = toRep(b);
     const rep_t aAbs = aInt & absMask;
     const rep_t bAbs = bInt & absMask;
-
+    
     if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
     if ((aAbs | bAbs) == 0) return GE_EQUAL;
     if ((aInt & bInt) >= 0) {

third_party/compiler_rt/comparesf2.c

@@ -52,18 +52,18 @@ enum LE_RESULT {
 
 COMPILER_RT_ABI enum LE_RESULT
 __lesf2(fp_t a, fp_t b) {
-
+    
     const srep_t aInt = toRep(a);
     const srep_t bInt = toRep(b);
     const rep_t aAbs = aInt & absMask;
     const rep_t bAbs = bInt & absMask;
-
+    
     // If either a or b is NaN, they are unordered.
     if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
-
+    
     // If a and b are both zeros, they are equal.
     if ((aAbs | bAbs) == 0) return LE_EQUAL;
-
+    
     // If at least one of a and b is positive, we get the same result comparing
     // a and b as signed integers as we would with a fp_ting-point compare.
     if ((aInt & bInt) >= 0) {
@@ -71,7 +71,7 @@ __lesf2(fp_t a, fp_t b) {
         else if (aInt == bInt) return LE_EQUAL;
         else return LE_GREATER;
     }
-
+    
     // Otherwise, both are negative, so we need to flip the sense of the
     // comparison to get the correct result.  (This assumes a twos- or ones-
     // complement integer representation; if integers are represented in a
@@ -98,12 +98,12 @@ enum GE_RESULT {
 
 COMPILER_RT_ABI enum GE_RESULT
 __gesf2(fp_t a, fp_t b) {
-
+    
     const srep_t aInt = toRep(a);
     const srep_t bInt = toRep(b);
     const rep_t aAbs = aInt & absMask;
     const rep_t bAbs = bInt & absMask;
-
+    
     if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
     if ((aAbs | bAbs) == 0) return GE_EQUAL;
     if ((aInt & bInt) >= 0) {

third_party/compiler_rt/divdf3.c

@@ -25,36 +25,36 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __divdf3(fp_t a, fp_t b) {
-
+    
     const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
     const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
     const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
-
+    
     rep_t aSignificand = toRep(a) & significandMask;
     rep_t bSignificand = toRep(b) & significandMask;
     int scale = 0;
-
+    
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
-
+        
         const rep_t aAbs = toRep(a) & absMask;
         const rep_t bAbs = toRep(b) & absMask;
-
+        
         // NaN / anything = qNaN
         if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
         // anything / NaN = qNaN
         if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
-
+        
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) return fromRep(qnanRep);
             // infinity / anything else = +/- infinity
             else return fromRep(aAbs | quotientSign);
         }
-
+        
         // anything else / infinity = +/- 0
         if (bAbs == infRep) return fromRep(quotientSign);
-
+        
         if (!aAbs) {
             // zero / zero = NaN
             if (!bAbs) return fromRep(qnanRep);
@@ -63,28 +63,28 @@ __divdf3(fp_t a, fp_t b) {
         }
         // anything else / zero = +/- infinity
         if (!bAbs) return fromRep(infRep | quotientSign);
-
+        
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
         // include the necessary exponent adjustment.
         if (aAbs < implicitBit) scale += normalize(&aSignificand);
         if (bAbs < implicitBit) scale -= normalize(&bSignificand);
     }
-
+    
     // Or in the implicit significand bit.  (If we fell through from the
     // denormal path it was already set by normalize( ), but setting it twice
     // won't hurt anything.)
     aSignificand |= implicitBit;
     bSignificand |= implicitBit;
     int quotientExponent = aExponent - bExponent + scale;
-
+    
     // Align the significand of b as a Q31 fixed-point number in the range
     // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
     // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
     // is accurate to about 3.5 binary digits.
     const uint32_t q31b = bSignificand >> 21;
     uint32_t recip32 = UINT32_C(0x7504f333) - q31b;
-
+    
     // Now refine the reciprocal estimate using a Newton-Raphson iteration:
     //
     //     x1 = x0 * (2 - x0 * b)
@@ -99,13 +99,13 @@ __divdf3(fp_t a, fp_t b) {
     recip32 = (uint64_t)recip32 * correction32 >> 31;
     correction32 = -((uint64_t)recip32 * q31b >> 32);
     recip32 = (uint64_t)recip32 * correction32 >> 31;
-
+    
     // recip32 might have overflowed to exactly zero in the preceding
     // computation if the high word of b is exactly 1.0.  This would sabotage
     // the full-width final stage of the computation that follows, so we adjust
     // recip32 downward by one bit.
     recip32--;
-
+    
     // We need to perform one more iteration to get us to 56 binary digits;
     // The last iteration needs to happen with extra precision.
     const uint32_t q63blo = bSignificand << 11;
@@ -114,14 +114,14 @@ __divdf3(fp_t a, fp_t b) {
     uint32_t cHi = correction >> 32;
     uint32_t cLo = correction;
     reciprocal = (uint64_t)recip32*cHi + ((uint64_t)recip32*cLo >> 32);
-
+    
     // We already adjusted the 32-bit estimate, now we need to adjust the final
     // 64-bit reciprocal estimate downward to ensure that it is strictly smaller
     // than the infinitely precise exact reciprocal.  Because the computation
     // of the Newton-Raphson step is truncating at every step, this adjustment
     // is small; most of the work is already done.
     reciprocal -= 2;
-
+    
     // The numerical reciprocal is accurate to within 2^-56, lies in the
     // interval [0.5, 1.0), and is strictly smaller than the true reciprocal
     // of b.  Multiplying a by this reciprocal thus gives a numerical q = a/b
@@ -131,12 +131,12 @@ __divdf3(fp_t a, fp_t b) {
     //    2. q is in the interval [0.5, 2.0)
     //    3. the error in q is bounded away from 2^-53 (actually, we have a
     //       couple of bits to spare, but this is all we need).
-
+    
     // We need a 64 x 64 multiply high to compute q, which isn't a basic
     // operation in C, so we need to be a little bit fussy.
     rep_t quotient, quotientLo;
     wideMultiply(aSignificand << 2, reciprocal, &quotient, &quotientLo);
-
+    
     // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
     // In either case, we are going to compute a residual of the form
     //
@@ -145,7 +145,7 @@ __divdf3(fp_t a, fp_t b) {
     // We know from the construction of q that r satisfies:
     //
     //     0 <= r < ulp(q)*b
-    //
+    // 
     // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we
     // already have the correct result.  The exact halfway case cannot occur.
     // We also take this time to right shift quotient if it falls in the [1,2)
@@ -158,20 +158,20 @@ __divdf3(fp_t a, fp_t b) {
         quotient >>= 1;
         residual = (aSignificand << 52) - quotient * bSignificand;
     }
-
+    
     const int writtenExponent = quotientExponent + exponentBias;
-
+    
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
         return fromRep(infRep | quotientSign);
     }
-
+    
     else if (writtenExponent < 1) {
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
         return fromRep(quotientSign);
     }
-
+    
     else {
         const bool round = (residual << 1) > bSignificand;
         // Clear the implicit bit

third_party/compiler_rt/divmodsi4.c

@@ -24,7 +24,7 @@ __divmodsi4(si_int a, si_int b, si_int* rem)
 {
   si_int d = __divsi3(a,b);
   *rem = a - (d*b);
-  return d;
+  return d; 
 }
 
 

third_party/compiler_rt/divsf3.c

@@ -25,36 +25,36 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __divsf3(fp_t a, fp_t b) {
-
+    
     const unsigned int aExponent = toRep(a) >> significandBits & maxExponent;
     const unsigned int bExponent = toRep(b) >> significandBits & maxExponent;
     const rep_t quotientSign = (toRep(a) ^ toRep(b)) & signBit;
-
+    
     rep_t aSignificand = toRep(a) & significandMask;
     rep_t bSignificand = toRep(b) & significandMask;
     int scale = 0;
-
+    
     // Detect if a or b is zero, denormal, infinity, or NaN.
     if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) {
-
+        
         const rep_t aAbs = toRep(a) & absMask;
         const rep_t bAbs = toRep(b) & absMask;
-
+        
         // NaN / anything = qNaN
         if (aAbs > infRep) return fromRep(toRep(a) | quietBit);
         // anything / NaN = qNaN
         if (bAbs > infRep) return fromRep(toRep(b) | quietBit);
-
+        
         if (aAbs == infRep) {
             // infinity / infinity = NaN
             if (bAbs == infRep) return fromRep(qnanRep);
             // infinity / anything else = +/- infinity
             else return fromRep(aAbs | quotientSign);
         }
-
+        
         // anything else / infinity = +/- 0
         if (bAbs == infRep) return fromRep(quotientSign);
-
+        
         if (!aAbs) {
             // zero / zero = NaN
             if (!bAbs) return fromRep(qnanRep);
@@ -63,28 +63,28 @@ __divsf3(fp_t a, fp_t b) {
         }
         // anything else / zero = +/- infinity
         if (!bAbs) return fromRep(infRep | quotientSign);
-
+        
         // one or both of a or b is denormal, the other (if applicable) is a
         // normal number.  Renormalize one or both of a and b, and set scale to
         // include the necessary exponent adjustment.
         if (aAbs < implicitBit) scale += normalize(&aSignificand);
         if (bAbs < implicitBit) scale -= normalize(&bSignificand);
     }
-
+    
     // Or in the implicit significand bit.  (If we fell through from the
     // denormal path it was already set by normalize( ), but setting it twice
     // won't hurt anything.)
     aSignificand |= implicitBit;
     bSignificand |= implicitBit;
     int quotientExponent = aExponent - bExponent + scale;
-
+    
     // Align the significand of b as a Q31 fixed-point number in the range
     // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax
     // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This
     // is accurate to about 3.5 binary digits.
     uint32_t q31b = bSignificand << 8;
     uint32_t reciprocal = UINT32_C(0x7504f333) - q31b;
-
+    
     // Now refine the reciprocal estimate using a Newton-Raphson iteration:
     //
     //     x1 = x0 * (2 - x0 * b)
@@ -99,7 +99,7 @@ __divsf3(fp_t a, fp_t b) {
     reciprocal = (uint64_t)reciprocal * correction >> 31;
     correction = -((uint64_t)reciprocal * q31b >> 32);
     reciprocal = (uint64_t)reciprocal * correction >> 31;
-
+    
     // Exhaustive testing shows that the error in reciprocal after three steps
     // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our
     // expectations.  We bump the reciprocal by a tiny value to force the error
@@ -107,7 +107,7 @@ __divsf3(fp_t a, fp_t b) {
     // be specific).  This also causes 1/1 to give a sensible approximation
     // instead of zero (due to overflow).
     reciprocal -= 2;
-
+    
     // The numerical reciprocal is accurate to within 2^-28, lies in the
     // interval [0x1.000000eep-1, 0x1.fffffffcp-1], and is strictly smaller
     // than the true reciprocal of b.  Multiplying a by this reciprocal thus
@@ -119,9 +119,9 @@ __divsf3(fp_t a, fp_t b) {
     //       from the fact that we truncate the product, and the 2^27 term
     //       is the error in the reciprocal of b scaled by the maximum
     //       possible value of a.  As a consequence of this error bound,
-    //       either q or nextafter(q) is the correctly rounded
+    //       either q or nextafter(q) is the correctly rounded 
     rep_t quotient = (uint64_t)reciprocal*(aSignificand << 1) >> 32;
-
+    
     // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
     // In either case, we are going to compute a residual of the form
     //
@@ -130,7 +130,7 @@ __divsf3(fp_t a, fp_t b) {
     // We know from the construction of q that r satisfies:
     //
     //     0 <= r < ulp(q)*b
-    //
+    // 
     // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we
     // already have the correct result.  The exact halfway case cannot occur.
     // We also take this time to right shift quotient if it falls in the [1,2)
@@ -145,18 +145,18 @@ __divsf3(fp_t a, fp_t b) {
     }
 
     const int writtenExponent = quotientExponent + exponentBias;
-
+    
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
         return fromRep(infRep | quotientSign);
     }
-
+    
     else if (writtenExponent < 1) {
         // Flush denormals to zero.  In the future, it would be nice to add
         // code to round them correctly.
         return fromRep(quotientSign);
     }
-
+    
     else {
         const bool round = (residual << 1) > bSignificand;
         // Clear the implicit bit

third_party/compiler_rt/fixunsxfdi.c

@@ -25,7 +25,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
  *             du_int is a 64 bit integral type
- *             value in long double is representable in du_int or is negative
+ *             value in long double is representable in du_int or is negative 
  *                 (no range checking performed)
  */
 

third_party/compiler_rt/fixunsxfsi.c

@@ -25,7 +25,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
  *             su_int is a 32 bit integral type
- *             value in long double is representable in su_int or is negative
+ *             value in long double is representable in su_int or is negative 
  */
 
 /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |

third_party/compiler_rt/fixunsxfti.c

@@ -25,7 +25,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
  *             tu_int is a 128 bit integral type
- *             value in long double is representable in tu_int or is negative
+ *             value in long double is representable in tu_int or is negative 
  */
 
 /* gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |

third_party/compiler_rt/floatdisf.c

@@ -17,9 +17,9 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Returns: convert a to a float, rounding toward even.*/
 
-/* Assumption: float is a IEEE 32 bit floating point type
+/* Assumption: float is a IEEE 32 bit floating point type 
  *             di_int is a 64 bit integral type
- */
+ */ 
 
 /* seee eeee emmm mmmm mmmm mmmm mmmm mmmm */
 
@@ -37,13 +37,13 @@ __floatdisf(di_int a)
     int e = sd - 1;             /* exponent */
     if (sd > FLT_MANT_DIG)
     {
-        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
-         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
-         *                                                12345678901234567890123456
-         *  1 = msb 1 bit
-         *  P = bit FLT_MANT_DIG-1 bits to the right of 1
-         *  Q = bit FLT_MANT_DIG bits to the right of 1
-         *  R = "or" of all bits to the right of Q
+        /*  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx 
+         *  finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR 
+         *                                                12345678901234567890123456 
+         *  1 = msb 1 bit 
+         *  P = bit FLT_MANT_DIG-1 bits to the right of 1 
+         *  Q = bit FLT_MANT_DIG bits to the right of 1   
+         *  R = "or" of all bits to the right of Q 
          */
         switch (sd)
         {

third_party/compiler_rt/floatdixf.c

@@ -11,7 +11,7 @@
  * This file implements __floatdixf for the compiler_rt library.
  *
  * ===----------------------------------------------------------------------===
- */
+ */ 
 
 STATIC_YOINK("huge_compiler_rt_license");
 

third_party/compiler_rt/floatsidf.c

@@ -23,30 +23,30 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __floatsidf(int a) {
-
+    
     const int aWidth = sizeof a * CHAR_BIT;
-
+    
     // Handle zero as a special case to protect clz
     if (a == 0)
         return fromRep(0);
-
+    
     // All other cases begin by extracting the sign and absolute value of a
     rep_t sign = 0;
     if (a < 0) {
         sign = signBit;
         a = -a;
     }
-
+    
     // Exponent of (fp_t)a is the width of abs(a).
     const int exponent = (aWidth - 1) - __builtin_clz(a);
     rep_t result;
-
+    
     // Shift a into the significand field and clear the implicit bit.  Extra
     // cast to unsigned int is necessary to get the correct behavior for
     // the input INT_MIN.
     const int shift = significandBits - exponent;
     result = (rep_t)(unsigned int)a << shift ^ implicitBit;
-
+    
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     // Insert the sign bit and return

third_party/compiler_rt/floatsisf.c

@@ -23,24 +23,24 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __floatsisf(int a) {
-
+    
     const int aWidth = sizeof a * CHAR_BIT;
-
+    
     // Handle zero as a special case to protect clz
     if (a == 0)
         return fromRep(0);
-
+    
     // All other cases begin by extracting the sign and absolute value of a
     rep_t sign = 0;
     if (a < 0) {
         sign = signBit;
         a = -a;
     }
-
+    
     // Exponent of (fp_t)a is the width of abs(a).
     const int exponent = (aWidth - 1) - __builtin_clz(a);
     rep_t result;
-
+    
     // Shift a into the significand field, rounding if it is a right-shift
     if (exponent <= significandBits) {
         const int shift = significandBits - exponent;
@@ -52,7 +52,7 @@ __floatsisf(int a) {
         if (round > signBit) result++;
         if (round == signBit) result += result & 1;
     }
-
+    
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     // Insert the sign bit and return

third_party/compiler_rt/floattisf.c

@@ -21,7 +21,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Returns: convert a to a float, rounding toward even. */
 
-/* Assumption: float is a IEEE 32 bit floating point type
+/* Assumption: float is a IEEE 32 bit floating point type 
  *             ti_int is a 128 bit integral type
  */
 

third_party/compiler_rt/floatundisf.c

@@ -17,7 +17,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Returns: convert a to a float, rounding toward even. */
 
-/* Assumption: float is a IEEE 32 bit floating point type
+/* Assumption: float is a IEEE 32 bit floating point type 
  *            du_int is a 64 bit integral type
  */
 

third_party/compiler_rt/floatunsidf.c

@@ -23,20 +23,20 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __floatunsidf(unsigned int a) {
-
+    
     const int aWidth = sizeof a * CHAR_BIT;
-
+    
     // Handle zero as a special case to protect clz
     if (a == 0) return fromRep(0);
-
+    
     // Exponent of (fp_t)a is the width of abs(a).
     const int exponent = (aWidth - 1) - __builtin_clz(a);
     rep_t result;
-
+    
     // Shift a into the significand field and clear the implicit bit.
     const int shift = significandBits - exponent;
     result = (rep_t)a << shift ^ implicitBit;
-
+    
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     return fromRep(result);

third_party/compiler_rt/floatunsisf.c

@@ -23,16 +23,16 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 COMPILER_RT_ABI fp_t
 __floatunsisf(unsigned int a) {
-
+    
     const int aWidth = sizeof a * CHAR_BIT;
-
+    
     // Handle zero as a special case to protect clz
     if (a == 0) return fromRep(0);
-
+    
     // Exponent of (fp_t)a is the width of abs(a).
     const int exponent = (aWidth - 1) - __builtin_clz(a);
     rep_t result;
-
+    
     // Shift a into the significand field, rounding if it is a right-shift
     if (exponent <= significandBits) {
         const int shift = significandBits - exponent;
@@ -44,7 +44,7 @@ __floatunsisf(unsigned int a) {
         if (round > signBit) result++;
         if (round == signBit) result += result & 1;
     }
-
+    
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     return fromRep(result);

third_party/compiler_rt/floatuntisf.c

@@ -21,7 +21,7 @@ STATIC_YOINK("huge_compiler_rt_license");
 
 /* Returns: convert a to a float, rounding toward even. */
 
-/* Assumption: float is a IEEE 32 bit floating point type
+/* Assumption: float is a IEEE 32 bit floating point type 
  *             tu_int is a 128 bit integral type
  */
 

third_party/compiler_rt/mulodi4.c

@@ -27,7 +27,7 @@ __mulodi4(di_int a, di_int b, int* overflow)
     const int N = (int)(sizeof(di_int) * CHAR_BIT);
     const di_int MIN = (di_int)1 << (N-1);
     const di_int MAX = ~MIN;
-    *overflow = 0;
+    *overflow = 0; 
     di_int result = a * b;
     if (a == MIN)
     {

third_party/compiler_rt/mulosi4.c

@@ -27,7 +27,7 @@ __mulosi4(si_int a, si_int b, int* overflow)
     const int N = (int)(sizeof(si_int) * CHAR_BIT);
     const si_int MIN = (si_int)1 << (N-1);
     const si_int MAX = ~MIN;
-    *overflow = 0;
+    *overflow = 0; 
     si_int result = a * b;
     if (a == MIN)
     {

third_party/compiler_rt/parityti2.c

@@ -11,7 +11,7 @@
  * This file implements __parityti2 for the compiler_rt library.
  *
  * ===----------------------------------------------------------------------===
- */
+ */ 
 
 STATIC_YOINK("huge_compiler_rt_license");
 

third_party/compiler_rt/udivmoddi4.c

@@ -64,7 +64,7 @@ __udivmoddi4(du_int a, du_int b, du_int* rem)
             /* K X
              * ---
              * 0 0
-             */
+             */ 
             if (rem)
                 *rem = n.s.high % d.s.low;
             return n.s.high / d.s.low;