15 files changed, 671 insertions, 705 deletions

diff --git a/lib/builtins/ppc/DD.h b/lib/builtins/ppc/DD.h
index 3e5f9e58c138..8f31a962fc77 100644
--- a/lib/builtins/ppc/DD.h
+++ b/lib/builtins/ppc/DD.h
@@ -4,20 +4,20 @@
 #include "../int_lib.h"
 
 typedef union {
-	long double ld;
-	struct {
-		double hi;
-		double lo;
-	}s;
+  long double ld;
+  struct {
+    double hi;
+    double lo;
+  } s;
 } DD;
 
-typedef union { 
-	double d;
-	uint64_t x;
+typedef union {
+  double d;
+  uint64_t x;
 } doublebits;
 
-#define LOWORDER(xy,xHi,xLo,yHi,yLo) \
-	(((((xHi)*(yHi) - (xy)) + (xHi)*(yLo)) + (xLo)*(yHi)) + (xLo)*(yLo))
+#define LOWORDER(xy, xHi, xLo, yHi, yLo)                                       \
+  (((((xHi) * (yHi) - (xy)) + (xHi) * (yLo)) + (xLo) * (yHi)) + (xLo) * (yLo))
 
 static __inline ALWAYS_INLINE double local_fabs(double x) {
   doublebits result = {.d = x};
@@ -42,4 +42,4 @@ long double __gcc_qsub(long double, long double);
 long double __gcc_qmul(long double, long double);
 long double __gcc_qdiv(long double, long double);
 
-#endif /* COMPILERRT_DD_HEADER */
+#endif // COMPILERRT_DD_HEADER
diff --git a/lib/builtins/ppc/divtc3.c b/lib/builtins/ppc/divtc3.c
index ef532b841145..afaccf5a8fd6 100644
--- a/lib/builtins/ppc/divtc3.c
+++ b/lib/builtins/ppc/divtc3.c
@@ -1,9 +1,9 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "DD.h"
 #include "../int_math.h"
+#include "DD.h"
 // Use DOUBLE_PRECISION because the soft-fp method we use is logb (on the upper
 // half of the long doubles), even though this file defines complex division for
 // 128-bit floats.
@@ -12,86 +12,85 @@
 
 #if !defined(CRT_INFINITY) && defined(HUGE_VAL)
 #define CRT_INFINITY HUGE_VAL
-#endif /* CRT_INFINITY */
+#endif // CRT_INFINITY
+
+#define makeFinite(x)                                                          \
+  {                                                                            \
+    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi);        \
+    (x).s.lo = 0.0;                                                            \
+  }
+
+long double _Complex __divtc3(long double a, long double b, long double c,
+                              long double d) {
+  DD cDD = {.ld = c};
+  DD dDD = {.ld = d};
+
+  int ilogbw = 0;
+  const double logbw =
+      __compiler_rt_logb(crt_fmax(crt_fabs(cDD.s.hi), crt_fabs(dDD.s.hi)));
+
+  if (crt_isfinite(logbw)) {
+    ilogbw = (int)logbw;
+
+    cDD.s.hi = crt_scalbn(cDD.s.hi, -ilogbw);
+    cDD.s.lo = crt_scalbn(cDD.s.lo, -ilogbw);
+    dDD.s.hi = crt_scalbn(dDD.s.hi, -ilogbw);
+    dDD.s.lo = crt_scalbn(dDD.s.lo, -ilogbw);
+  }
+
+  const long double denom =
+      __gcc_qadd(__gcc_qmul(cDD.ld, cDD.ld), __gcc_qmul(dDD.ld, dDD.ld));
+  const long double realNumerator =
+      __gcc_qadd(__gcc_qmul(a, cDD.ld), __gcc_qmul(b, dDD.ld));
+  const long double imagNumerator =
+      __gcc_qsub(__gcc_qmul(b, cDD.ld), __gcc_qmul(a, dDD.ld));
+
+  DD real = {.ld = __gcc_qdiv(realNumerator, denom)};
+  DD imag = {.ld = __gcc_qdiv(imagNumerator, denom)};
+
+  real.s.hi = crt_scalbn(real.s.hi, -ilogbw);
+  real.s.lo = crt_scalbn(real.s.lo, -ilogbw);
+  imag.s.hi = crt_scalbn(imag.s.hi, -ilogbw);
+  imag.s.lo = crt_scalbn(imag.s.lo, -ilogbw);
 
-#define makeFinite(x) { \
-    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
-    (x).s.lo = 0.0;                                                     \
+  if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) {
+    DD aDD = {.ld = a};
+    DD bDD = {.ld = b};
+    DD rDD = {.ld = denom};
+
+    if ((rDD.s.hi == 0.0) && (!crt_isnan(aDD.s.hi) || !crt_isnan(bDD.s.hi))) {
+      real.s.hi = crt_copysign(CRT_INFINITY, cDD.s.hi) * aDD.s.hi;
+      real.s.lo = 0.0;
+      imag.s.hi = crt_copysign(CRT_INFINITY, cDD.s.hi) * bDD.s.hi;
+      imag.s.lo = 0.0;
+    }
+
+    else if ((crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) &&
+             crt_isfinite(cDD.s.hi) && crt_isfinite(dDD.s.hi)) {
+      makeFinite(aDD);
+      makeFinite(bDD);
+      real.s.hi = CRT_INFINITY * (aDD.s.hi * cDD.s.hi + bDD.s.hi * dDD.s.hi);
+      real.s.lo = 0.0;
+      imag.s.hi = CRT_INFINITY * (bDD.s.hi * cDD.s.hi - aDD.s.hi * dDD.s.hi);
+      imag.s.lo = 0.0;
+    }
+
+    else if ((crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) &&
+             crt_isfinite(aDD.s.hi) && crt_isfinite(bDD.s.hi)) {
+      makeFinite(cDD);
+      makeFinite(dDD);
+      real.s.hi =
+          crt_copysign(0.0, (aDD.s.hi * cDD.s.hi + bDD.s.hi * dDD.s.hi));
+      real.s.lo = 0.0;
+      imag.s.hi =
+          crt_copysign(0.0, (bDD.s.hi * cDD.s.hi - aDD.s.hi * dDD.s.hi));
+      imag.s.lo = 0.0;
+    }
   }
 
-long double _Complex
-__divtc3(long double a, long double b, long double c, long double d)
-{
-	DD cDD = { .ld = c };
-	DD dDD = { .ld = d };
-	
-	int ilogbw = 0;
-	const double logbw = __compiler_rt_logb(
-		crt_fmax(crt_fabs(cDD.s.hi), crt_fabs(dDD.s.hi)));
-
-        if (crt_isfinite(logbw))
-	{
-		ilogbw = (int)logbw;
-		
-		cDD.s.hi = crt_scalbn(cDD.s.hi, -ilogbw);
-		cDD.s.lo = crt_scalbn(cDD.s.lo, -ilogbw);
-		dDD.s.hi = crt_scalbn(dDD.s.hi, -ilogbw);
-		dDD.s.lo = crt_scalbn(dDD.s.lo, -ilogbw);
-	}
-	
-	const long double denom = __gcc_qadd(__gcc_qmul(cDD.ld, cDD.ld), __gcc_qmul(dDD.ld, dDD.ld));
-	const long double realNumerator = __gcc_qadd(__gcc_qmul(a,cDD.ld), __gcc_qmul(b,dDD.ld));
-	const long double imagNumerator = __gcc_qsub(__gcc_qmul(b,cDD.ld), __gcc_qmul(a,dDD.ld));
-	
-	DD real = { .ld = __gcc_qdiv(realNumerator, denom) };
-	DD imag = { .ld = __gcc_qdiv(imagNumerator, denom) };
-	
-	real.s.hi = crt_scalbn(real.s.hi, -ilogbw);
-	real.s.lo = crt_scalbn(real.s.lo, -ilogbw);
-	imag.s.hi = crt_scalbn(imag.s.hi, -ilogbw);
-	imag.s.lo = crt_scalbn(imag.s.lo, -ilogbw);
-	
-	if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi))
-	{
-		DD aDD = { .ld = a };
-		DD bDD = { .ld = b };
-		DD rDD = { .ld = denom };
-		
-		if ((rDD.s.hi == 0.0) && (!crt_isnan(aDD.s.hi) ||
-                                          !crt_isnan(bDD.s.hi)))
-		{
-			real.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * aDD.s.hi;
-			real.s.lo = 0.0;
-			imag.s.hi = crt_copysign(CRT_INFINITY,cDD.s.hi) * bDD.s.hi;
-			imag.s.lo = 0.0;
-		}
-		
-		else if ((crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) &&
-                         crt_isfinite(cDD.s.hi) && crt_isfinite(dDD.s.hi))
-		{
-			makeFinite(aDD);
-			makeFinite(bDD);
-			real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi);
-			real.s.lo = 0.0;
-			imag.s.hi = CRT_INFINITY * (bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi);
-			imag.s.lo = 0.0;
-		}
-		
-		else if ((crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) &&
-                         crt_isfinite(aDD.s.hi) && crt_isfinite(bDD.s.hi))
-		{
-			makeFinite(cDD);
-			makeFinite(dDD);
-			real.s.hi = crt_copysign(0.0,(aDD.s.hi*cDD.s.hi + bDD.s.hi*dDD.s.hi));
-			real.s.lo = 0.0;
-			imag.s.hi = crt_copysign(0.0,(bDD.s.hi*cDD.s.hi - aDD.s.hi*dDD.s.hi));
-			imag.s.lo = 0.0;
-		}
-	}
-	
-	long double _Complex z;
-	__real__ z = real.ld;
-	__imag__ z = imag.ld;
-	
-	return z;
+  long double _Complex z;
+  __real__ z = real.ld;
+  __imag__ z = imag.ld;
+
+  return z;
 }
diff --git a/lib/builtins/ppc/fixtfdi.c b/lib/builtins/ppc/fixtfdi.c
index 2c7c0f8e279f..a97aaf095846 100644
--- a/lib/builtins/ppc/fixtfdi.c
+++ b/lib/builtins/ppc/fixtfdi.c
@@ -1,104 +1,98 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* int64_t __fixunstfdi(long double x);
- * This file implements the PowerPC 128-bit double-double -> int64_t conversion
- */
+// int64_t __fixunstfdi(long double x);
+// This file implements the PowerPC 128-bit double-double -> int64_t conversion
 
-#include "DD.h"
 #include "../int_math.h"
+#include "DD.h"
+
+uint64_t __fixtfdi(long double input) {
+  const DD x = {.ld = input};
+  const doublebits hibits = {.d = x.s.hi};
+
+  const uint32_t absHighWord =
+      (uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff);
+  const uint32_t absHighWordMinusOne = absHighWord - UINT32_C(0x3ff00000);
+
+  // If (1.0 - tiny) <= input < 0x1.0p63:
+  if (UINT32_C(0x03f00000) > absHighWordMinusOne) {
+    // Do an unsigned conversion of the absolute value, then restore the sign.
+    const int unbiasedHeadExponent = absHighWordMinusOne >> 20;
+
+    int64_t result = hibits.x & INT64_C(0x000fffffffffffff); // mantissa(hi)
+    result |= INT64_C(0x0010000000000000); // matissa(hi) with implicit bit
+    result <<= 10; // mantissa(hi) with one zero preceding bit.
+
+    const int64_t hiNegationMask = ((int64_t)(hibits.x)) >> 63;
+
+    // If the tail is non-zero, we need to patch in the tail bits.
+    if (0.0 != x.s.lo) {
+      const doublebits lobits = {.d = x.s.lo};
+      int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+      tailMantissa |= INT64_C(0x0010000000000000);
+
+      // At this point we have the mantissa of |tail|
+      // We need to negate it if head and tail have different signs.
+      const int64_t loNegationMask = ((int64_t)(lobits.x)) >> 63;
+      const int64_t negationMask = loNegationMask ^ hiNegationMask;
+      tailMantissa = (tailMantissa ^ negationMask) - negationMask;
+
+      // Now we have the mantissa of tail as a signed 2s-complement integer
+
+      const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+
+      // Shift the tail mantissa into the right position, accounting for the
+      // bias of 10 that we shifted the head mantissa by.
+      tailMantissa >>=
+          (unbiasedHeadExponent - (biasedTailExponent - (1023 - 10)));
+
+      result += tailMantissa;
+    }
+
+    result >>= (62 - unbiasedHeadExponent);
+
+    // Restore the sign of the result and return
+    result = (result ^ hiNegationMask) - hiNegationMask;
+    return result;
+  }
+
+  // Edge cases handled here:
+
+  // |x| < 1, result is zero.
+  if (1.0 > crt_fabs(x.s.hi))
+    return INT64_C(0);
+
+  // x very close to INT64_MIN, care must be taken to see which side we are on.
+  if (x.s.hi == -0x1.0p63) {
+
+    int64_t result = INT64_MIN;
+
+    if (0.0 < x.s.lo) {
+      // If the tail is positive, the correct result is something other than
+      // INT64_MIN. we'll need to figure out what it is.
+
+      const doublebits lobits = {.d = x.s.lo};
+      int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+      tailMantissa |= INT64_C(0x0010000000000000);
+
+      // Now we negate the tailMantissa
+      tailMantissa = (tailMantissa ^ INT64_C(-1)) + INT64_C(1);
+
+      // And shift it by the appropriate amount
+      const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+      tailMantissa >>= 1075 - biasedTailExponent;
+
+      result -= tailMantissa;
+    }
+
+    return result;
+  }
 
-uint64_t __fixtfdi(long double input)
-{
-	const DD x = { .ld = input };
-	const doublebits hibits = { .d = x.s.hi };
-	
-	const uint32_t absHighWord = (uint32_t)(hibits.x >> 32) & UINT32_C(0x7fffffff);
-	const uint32_t absHighWordMinusOne = absHighWord - UINT32_C(0x3ff00000);
-	
-	/* If (1.0 - tiny) <= input < 0x1.0p63: */
-	if (UINT32_C(0x03f00000) > absHighWordMinusOne)
-	{
-		/* Do an unsigned conversion of the absolute value, then restore the sign. */
-		const int unbiasedHeadExponent = absHighWordMinusOne >> 20;
-		
-		int64_t result = hibits.x & INT64_C(0x000fffffffffffff); /* mantissa(hi) */
-		result |= INT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
-		result <<= 10; /* mantissa(hi) with one zero preceding bit. */
-		
-		const int64_t hiNegationMask = ((int64_t)(hibits.x)) >> 63;
-		
-		/* If the tail is non-zero, we need to patch in the tail bits. */
-		if (0.0 != x.s.lo)
-		{
-			const doublebits lobits = { .d = x.s.lo };
-			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
-			tailMantissa |= INT64_C(0x0010000000000000);
-			
-			/* At this point we have the mantissa of |tail| */
-			/* We need to negate it if head and tail have different signs. */
-			const int64_t loNegationMask = ((int64_t)(lobits.x)) >> 63;
-			const int64_t negationMask = loNegationMask ^ hiNegationMask;
-			tailMantissa = (tailMantissa ^ negationMask) - negationMask;
-			
-			/* Now we have the mantissa of tail as a signed 2s-complement integer */
-			
-			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
-			
-			/* Shift the tail mantissa into the right position, accounting for the
-			 * bias of 10 that we shifted the head mantissa by.
-			 */ 
-			tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 10)));
-			
-			result += tailMantissa;
-		}
-		
-		result >>= (62 - unbiasedHeadExponent);
-		
-		/* Restore the sign of the result and return */
-		result = (result ^ hiNegationMask) - hiNegationMask;
-		return result;
-		
-	}
-
-	/* Edge cases handled here: */
-	
-	/* |x| < 1, result is zero. */
-	if (1.0 > crt_fabs(x.s.hi))
-		return INT64_C(0);
-	
-	/* x very close to INT64_MIN, care must be taken to see which side we are on. */
-	if (x.s.hi == -0x1.0p63) {
-		
-		int64_t result = INT64_MIN;
-		
-		if (0.0 < x.s.lo)
-		{
-			/* If the tail is positive, the correct result is something other than INT64_MIN.
-			 * we'll need to figure out what it is.
-			 */
-
-			const doublebits lobits = { .d = x.s.lo };
-			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
-			tailMantissa |= INT64_C(0x0010000000000000);
-			
-			/* Now we negate the tailMantissa */
-			tailMantissa = (tailMantissa ^ INT64_C(-1)) + INT64_C(1);
-			
-			/* And shift it by the appropriate amount */
-			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
-			tailMantissa >>= 1075 - biasedTailExponent;
-			
-			result -= tailMantissa;
-		}
-		
-		return result;
-	}
-	
-	/* Signed overflows, infinities, and NaNs */
-	if (x.s.hi > 0.0)
-		return INT64_MAX;
-	else
-		return INT64_MIN;
+  // Signed overflows, infinities, and NaNs
+  if (x.s.hi > 0.0)
+    return INT64_MAX;
+  else
+    return INT64_MIN;
 }
diff --git a/lib/builtins/ppc/fixunstfdi.c b/lib/builtins/ppc/fixunstfdi.c
index 5e6e2cedf6ac..8d53f372527a 100644
--- a/lib/builtins/ppc/fixunstfdi.c
+++ b/lib/builtins/ppc/fixunstfdi.c
@@ -1,59 +1,57 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* uint64_t __fixunstfdi(long double x); */
-/* This file implements the PowerPC 128-bit double-double -> uint64_t conversion */
+// uint64_t __fixunstfdi(long double x);
+// This file implements the PowerPC 128-bit double-double -> uint64_t conversion
 
 #include "DD.h"
 
-uint64_t __fixunstfdi(long double input)
-{
-	const DD x = { .ld = input };
-	const doublebits hibits = { .d = x.s.hi };
-	
-	const uint32_t highWordMinusOne = (uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000);
-	
-	/* If (1.0 - tiny) <= input < 0x1.0p64: */
-	if (UINT32_C(0x04000000) > highWordMinusOne)
-	{
-		const int unbiasedHeadExponent = highWordMinusOne >> 20;
-		
-		uint64_t result = hibits.x & UINT64_C(0x000fffffffffffff); /* mantissa(hi) */
-		result |= UINT64_C(0x0010000000000000); /* matissa(hi) with implicit bit */
-		result <<= 11; /* mantissa(hi) left aligned in the int64 field. */
-		
-		/* If the tail is non-zero, we need to patch in the tail bits. */
-		if (0.0 != x.s.lo)
-		{
-			const doublebits lobits = { .d = x.s.lo };
-			int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
-			tailMantissa |= INT64_C(0x0010000000000000);
-			
-			/* At this point we have the mantissa of |tail| */
-			
-			const int64_t negationMask = ((int64_t)(lobits.x)) >> 63;
-			tailMantissa = (tailMantissa ^ negationMask) - negationMask;
-			
-			/* Now we have the mantissa of tail as a signed 2s-complement integer */
-			
-			const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
-			
-			/* Shift the tail mantissa into the right position, accounting for the
-			 * bias of 11 that we shifted the head mantissa by.
-			 */
-			tailMantissa >>= (unbiasedHeadExponent - (biasedTailExponent - (1023 - 11)));
-			
-			result += tailMantissa;
-		}
-		
-		result >>= (63 - unbiasedHeadExponent);
-		return result;
-	}
-	
-	/* Edge cases are handled here, with saturation. */
-	if (1.0 > x.s.hi)
-		return UINT64_C(0);
-	else
-		return UINT64_MAX;
+uint64_t __fixunstfdi(long double input) {
+  const DD x = {.ld = input};
+  const doublebits hibits = {.d = x.s.hi};
+
+  const uint32_t highWordMinusOne =
+      (uint32_t)(hibits.x >> 32) - UINT32_C(0x3ff00000);
+
+  // If (1.0 - tiny) <= input < 0x1.0p64:
+  if (UINT32_C(0x04000000) > highWordMinusOne) {
+    const int unbiasedHeadExponent = highWordMinusOne >> 20;
+
+    uint64_t result = hibits.x & UINT64_C(0x000fffffffffffff); // mantissa(hi)
+    result |= UINT64_C(0x0010000000000000); // matissa(hi) with implicit bit
+    result <<= 11; // mantissa(hi) left aligned in the int64 field.
+
+    // If the tail is non-zero, we need to patch in the tail bits.
+    if (0.0 != x.s.lo) {
+      const doublebits lobits = {.d = x.s.lo};
+      int64_t tailMantissa = lobits.x & INT64_C(0x000fffffffffffff);
+      tailMantissa |= INT64_C(0x0010000000000000);
+
+      // At this point we have the mantissa of |tail|
+
+      const int64_t negationMask = ((int64_t)(lobits.x)) >> 63;
+      tailMantissa = (tailMantissa ^ negationMask) - negationMask;
+
+      // Now we have the mantissa of tail as a signed 2s-complement integer
+
+      const int biasedTailExponent = (int)(lobits.x >> 52) & 0x7ff;
+
+      // Shift the tail mantissa into the right position, accounting for the
+      // bias of 11 that we shifted the head mantissa by.
+      tailMantissa >>=
+          (unbiasedHeadExponent - (biasedTailExponent - (1023 - 11)));
+
+      result += tailMantissa;
+    }
+
+    result >>= (63 - unbiasedHeadExponent);
+    return result;
+  }
+
+  // Edge cases are handled here, with saturation.
+  if (1.0 > x.s.hi)
+    return UINT64_C(0);
+  else
+    return UINT64_MAX;
 }
diff --git a/lib/builtins/ppc/fixunstfti.c b/lib/builtins/ppc/fixunstfti.c
index fa21084cb576..1d19e01e3a91 100644
--- a/lib/builtins/ppc/fixunstfti.c
+++ b/lib/builtins/ppc/fixunstfti.c
@@ -1,9 +1,8 @@
 //===-- lib/builtins/ppc/fixunstfti.c - Convert long double->int128 *-C -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,10 +14,10 @@
 #include "../int_math.h"
 #define BIAS 1023
 
-/* Convert long double into an unsigned 128-bit integer. */
+// Convert long double into an unsigned 128-bit integer.
 __uint128_t __fixunstfti(long double input) {
 
-  /* If we are trying to convert a NaN, return the NaN bit pattern. */
+  // If we are trying to convert a NaN, return the NaN bit pattern.
   if (crt_isnan(input)) {
     return ((__uint128_t)0x7FF8000000000000ll) << 64 |
            (__uint128_t)0x0000000000000000ll;
@@ -26,59 +25,59 @@ __uint128_t __fixunstfti(long double input) {
 
   __uint128_t result, hiResult, loResult;
   int hiExponent, loExponent, shift;
-  /* The long double representation, with the high and low portions of
-   * the long double, and the corresponding bit patterns of each double. */
+  // The long double representation, with the high and low portions of
+  // the long double, and the corresponding bit patterns of each double.
   union {
     long double ld;
-    double d[2]; /* [0] is the high double, [1] is the low double. */
-    unsigned long long ull[2]; /* High and low doubles as 64-bit integers. */
+    double d[2];               // [0] is the high double, [1] is the low double.
+    unsigned long long ull[2]; // High and low doubles as 64-bit integers.
   } ldUnion;
 
-  /* If the long double is less than 1.0 or negative,
-   * return 0.0. */
+  // If the long double is less than 1.0 or negative,
+  // return 0.0.
   if (input < 1.0)
     return 0.0;
 
-  /* Retrieve the 64-bit patterns of high and low doubles.
-   * Compute the unbiased exponent of both high and low doubles by
-   * removing the signs, isolating the exponent, and subtracting
-   * the bias from it. */
+  // Retrieve the 64-bit patterns of high and low doubles.
+  // Compute the unbiased exponent of both high and low doubles by
+  // removing the signs, isolating the exponent, and subtracting
+  // the bias from it.
   ldUnion.ld = input;
   hiExponent = ((ldUnion.ull[0] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
   loExponent = ((ldUnion.ull[1] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
 
-  /* Convert each double into int64; they will be added to the int128 result.
-   * CASE 1: High or low double fits in int64
-   *      - Convert the each double normally into int64.
-   *
-   * CASE 2: High or low double does not fit in int64
-   *      - Scale the double to fit within a 64-bit integer
-   *      - Calculate the shift (amount to scale the double by in the int128)
-   *      - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF)
-   *      - Add BIAS+53 (0x4350000000000000) to exponent to correct the value
-   *      - Scale (move) the double to the correct place in the int128
-   *        (Move it by 2^53 places)
-   *
-   * Note: If the high double is assumed to be positive, an unsigned conversion
-   * from long double to 64-bit integer is needed. The low double can be either
-   * positive or negative, so a signed conversion is needed to retain the result
-   * of the low double and to ensure it does not simply get converted to 0. */
+  // Convert each double into int64; they will be added to the int128 result.
+  // CASE 1: High or low double fits in int64
+  //      - Convert the each double normally into int64.
+  //
+  // CASE 2: High or low double does not fit in int64
+  //      - Scale the double to fit within a 64-bit integer
+  //      - Calculate the shift (amount to scale the double by in the int128)
+  //      - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF)
+  //      - Add BIAS+53 (0x4350000000000000) to exponent to correct the value
+  //      - Scale (move) the double to the correct place in the int128
+  //        (Move it by 2^53 places)
+  //
+  // Note: If the high double is assumed to be positive, an unsigned conversion
+  // from long double to 64-bit integer is needed. The low double can be either
+  // positive or negative, so a signed conversion is needed to retain the result
+  // of the low double and to ensure it does not simply get converted to 0.
 
-  /* CASE 1 - High double fits in int64. */
+  // CASE 1 - High double fits in int64.
   if (hiExponent < 63) {
     hiResult = (unsigned long long)ldUnion.d[0];
   } else if (hiExponent < 128) {
-    /* CASE 2 - High double does not fit in int64, scale and convert it. */
+    // CASE 2 - High double does not fit in int64, scale and convert it.
     shift = hiExponent - 54;
     ldUnion.ull[0] &= 0x800FFFFFFFFFFFFFll;
     ldUnion.ull[0] |= 0x4350000000000000ll;
     hiResult = (unsigned long long)ldUnion.d[0];
     hiResult <<= shift;
   } else {
-    /* Detect cases for overflow. When the exponent of the high
-     * double is greater than 128 bits and when the long double
-     * input is positive, return the max 128-bit integer.
-     * For negative inputs with exponents > 128, return 1, like gcc. */
+    // Detect cases for overflow. When the exponent of the high
+    // double is greater than 128 bits and when the long double
+    // input is positive, return the max 128-bit integer.
+    // For negative inputs with exponents > 128, return 1, like gcc.
     if (ldUnion.d[0] > 0) {
       return ((__uint128_t)0xFFFFFFFFFFFFFFFFll) << 64 |
              (__uint128_t)0xFFFFFFFFFFFFFFFFll;
@@ -88,11 +87,11 @@ __uint128_t __fixunstfti(long double input) {
     }
   }
 
-  /* CASE 1 - Low double fits in int64. */
+  // CASE 1 - Low double fits in int64.
   if (loExponent < 63) {
     loResult = (long long)ldUnion.d[1];
   } else {
-    /* CASE 2 - Low double does not fit in int64, scale and convert it. */
+    // CASE 2 - Low double does not fit in int64, scale and convert it.
     shift = loExponent - 54;
     ldUnion.ull[1] &= 0x800FFFFFFFFFFFFFll;
     ldUnion.ull[1] |= 0x4350000000000000ll;
@@ -100,7 +99,7 @@ __uint128_t __fixunstfti(long double input) {
     loResult <<= shift;
   }
 
-  /* Add the high and low doublewords together to form a 128 bit integer. */
+  // Add the high and low doublewords together to form a 128 bit integer.
   result = loResult + hiResult;
   return result;
 }
diff --git a/lib/builtins/ppc/floatditf.c b/lib/builtins/ppc/floatditf.c
index beabdd017422..4c365418f082 100644
--- a/lib/builtins/ppc/floatditf.c
+++ b/lib/builtins/ppc/floatditf.c
@@ -1,36 +1,33 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __floatditf(long long x); */
-/* This file implements the PowerPC long long -> long double conversion */
+// long double __floatditf(long long x);
+// This file implements the PowerPC long long -> long double conversion
 
 #include "DD.h"
 
 long double __floatditf(int64_t a) {
-	
-	static const double twop32 = 0x1.0p32;
-	static const double twop52 = 0x1.0p52;
-	
-	doublebits low  = { .d = twop52 };
-	low.x |= a & UINT64_C(0x00000000ffffffff);	/* 0x1.0p52 + low 32 bits of a. */
-	
-	const double high_addend = (double)((int32_t)(a >> 32))*twop32 - twop52;
-	
-	/* At this point, we have two double precision numbers
-	 * high_addend and low.d, and we wish to return their sum
-	 * as a canonicalized long double:
-	 */
-
-	/* This implementation sets the inexact flag spuriously.
-	 * This could be avoided, but at some substantial cost.
-	*/
-
-	DD result;
-	
-	result.s.hi = high_addend + low.d;
-	result.s.lo = (high_addend - result.s.hi) + low.d;
-	
-	return result.ld;
-	
+
+  static const double twop32 = 0x1.0p32;
+  static const double twop52 = 0x1.0p52;
+
+  doublebits low = {.d = twop52};
+  low.x |= a & UINT64_C(0x00000000ffffffff); // 0x1.0p52 + low 32 bits of a.
+
+  const double high_addend = (double)((int32_t)(a >> 32)) * twop32 - twop52;
+
+  // At this point, we have two double precision numbers
+  // high_addend and low.d, and we wish to return their sum
+  // as a canonicalized long double:
+
+  // This implementation sets the inexact flag spuriously.
+  // This could be avoided, but at some substantial cost.
+
+  DD result;
+
+  result.s.hi = high_addend + low.d;
+  result.s.lo = (high_addend - result.s.hi) + low.d;
+
+  return result.ld;
 }
diff --git a/lib/builtins/ppc/floattitf.c b/lib/builtins/ppc/floattitf.c
index b8e297b6b8d9..6deac6498128 100644
--- a/lib/builtins/ppc/floattitf.c
+++ b/lib/builtins/ppc/floattitf.c
@@ -1,9 +1,8 @@
 //===-- lib/builtins/ppc/floattitf.c - Convert int128->long double -*-C -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,35 +13,34 @@
 
 #include <stdint.h>
 
-/* Conversions from signed and unsigned 64-bit int to long double. */
+// Conversions from signed and unsigned 64-bit int to long double.
 long double __floatditf(int64_t);
 long double __floatunditf(uint64_t);
 
-/* Convert a signed 128-bit integer to long double.
- * This uses the following property:  Let hi and lo be 64-bits each,
- * and let signed_val_k() and unsigned_val_k() be the value of the
- * argument interpreted as a signed or unsigned k-bit integer. Then,
- *
- * signed_val_128(hi,lo) = signed_val_64(hi) * 2^64 + unsigned_val_64(lo)
- * = (long double)hi * 2^64 + (long double)lo,
- *
- * where (long double)hi and (long double)lo are signed and
- * unsigned 64-bit integer to long double conversions, respectively.
- */
+// Convert a signed 128-bit integer to long double.
+// This uses the following property:  Let hi and lo be 64-bits each,
+// and let signed_val_k() and unsigned_val_k() be the value of the
+// argument interpreted as a signed or unsigned k-bit integer. Then,
+//
+// signed_val_128(hi,lo) = signed_val_64(hi) * 2^64 + unsigned_val_64(lo)
+// = (long double)hi * 2^64 + (long double)lo,
+//
+// where (long double)hi and (long double)lo are signed and
+// unsigned 64-bit integer to long double conversions, respectively.
 long double __floattitf(__int128_t arg) {
-  /* Split the int128 argument into 64-bit high and low int64 parts. */
+  // Split the int128 argument into 64-bit high and low int64 parts.
   int64_t ArgHiPart = (int64_t)(arg >> 64);
   uint64_t ArgLoPart = (uint64_t)arg;
 
-  /* Convert each 64-bit part into long double. The high part
-   * must be a signed conversion and the low part an unsigned conversion
-   * to ensure the correct result. */
+  // Convert each 64-bit part into long double. The high part
+  // must be a signed conversion and the low part an unsigned conversion
+  // to ensure the correct result.
   long double ConvertedHiPart = __floatditf(ArgHiPart);
   long double ConvertedLoPart = __floatunditf(ArgLoPart);
 
-  /* The low bit of ArgHiPart corresponds to the 2^64 bit in arg.
-   * Multiply the high part by 2^64 to undo the right shift by 64-bits
-   * done in the splitting. Then, add to the low part to obtain the
-   * final result. */
+  // The low bit of ArgHiPart corresponds to the 2^64 bit in arg.
+  // Multiply the high part by 2^64 to undo the right shift by 64-bits
+  // done in the splitting. Then, add to the low part to obtain the
+  // final result.
   return ((ConvertedHiPart * 0x1.0p64) + ConvertedLoPart);
 }
diff --git a/lib/builtins/ppc/floatunditf.c b/lib/builtins/ppc/floatunditf.c
index b12e1e738fd0..fb4cd3f91d86 100644
--- a/lib/builtins/ppc/floatunditf.c
+++ b/lib/builtins/ppc/floatunditf.c
@@ -1,41 +1,39 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __floatunditf(unsigned long long x); */
-/* This file implements the PowerPC unsigned long long -> long double conversion */
+// long double __floatunditf(unsigned long long x);
+// This file implements the PowerPC unsigned long long -> long double conversion
 
 #include "DD.h"
 
 long double __floatunditf(uint64_t a) {
-	
-	/* Begins with an exact copy of the code from __floatundidf */
-	
-	static const double twop52 = 0x1.0p52;
-	static const double twop84 = 0x1.0p84;
-	static const double twop84_plus_twop52 = 0x1.00000001p84;
-	
-	doublebits high = { .d = twop84 };
-	doublebits low  = { .d = twop52 };
-	
-	high.x |= a >> 32;							/* 0x1.0p84 + high 32 bits of a */
-	low.x |= a & UINT64_C(0x00000000ffffffff);	/* 0x1.0p52 + low 32 bits of a */
-	
-	const double high_addend = high.d - twop84_plus_twop52;
-	
-	/* At this point, we have two double precision numbers
-	 * high_addend and low.d, and we wish to return their sum
-	 * as a canonicalized long double:
-	 */
-
-	/* This implementation sets the inexact flag spuriously. */
-	/* This could be avoided, but at some substantial cost. */
-	
-	DD result;
-	
-	result.s.hi = high_addend + low.d;
-	result.s.lo = (high_addend - result.s.hi) + low.d;
-	
-	return result.ld;
-	
+
+  // Begins with an exact copy of the code from __floatundidf
+
+  static const double twop52 = 0x1.0p52;
+  static const double twop84 = 0x1.0p84;
+  static const double twop84_plus_twop52 = 0x1.00000001p84;
+
+  doublebits high = {.d = twop84};
+  doublebits low = {.d = twop52};
+
+  high.x |= a >> 32;                         // 0x1.0p84 + high 32 bits of a
+  low.x |= a & UINT64_C(0x00000000ffffffff); // 0x1.0p52 + low 32 bits of a
+
+  const double high_addend = high.d - twop84_plus_twop52;
+
+  // At this point, we have two double precision numbers
+  // high_addend and low.d, and we wish to return their sum
+  // as a canonicalized long double:
+
+  // This implementation sets the inexact flag spuriously.
+  // This could be avoided, but at some substantial cost.
+
+  DD result;
+
+  result.s.hi = high_addend + low.d;
+  result.s.lo = (high_addend - result.s.hi) + low.d;
+
+  return result.ld;
 }
diff --git a/lib/builtins/ppc/gcc_qadd.c b/lib/builtins/ppc/gcc_qadd.c
index 32e16e9d1d11..6e1e63cb530e 100644
--- a/lib/builtins/ppc/gcc_qadd.c
+++ b/lib/builtins/ppc/gcc_qadd.c
@@ -1,76 +1,74 @@
-/* This file is distributed under the University of Illinois Open Source
- *  License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __gcc_qadd(long double x, long double y);
- * This file implements the PowerPC 128-bit double-double add operation.
- * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
- */
+// long double __gcc_qadd(long double x, long double y);
+// This file implements the PowerPC 128-bit double-double add operation.
+// This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
 
 #include "DD.h"
 
-long double __gcc_qadd(long double x, long double y)
-{
-	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
-	
-	DD dst = { .ld = x }, src = { .ld = y };
-	
-	register double A = dst.s.hi, a = dst.s.lo,
-					B = src.s.hi, b = src.s.lo;
-	
-	/* If both operands are zero: */
-	if ((A == 0.0) && (B == 0.0)) {
-		dst.s.hi = A + B;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	/* If either operand is NaN or infinity: */
-	const doublebits abits = { .d = A };
-	const doublebits bbits = { .d = B };
-	if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
-		(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
-		dst.s.hi = A + B;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	/* If the computation overflows: */
-	/* This may be playing things a little bit fast and loose, but it will do for a start. */
-	const double testForOverflow = A + (B + (a + b));
-	const doublebits testbits = { .d = testForOverflow };
-	if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
-		dst.s.hi = testForOverflow;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	double H, h;
-	double T, t;
-	double W, w;
-	double Y;
-	
-	H = B + (A - (A + B));
-	T = b + (a - (a + b));
-	h = A + (B - (A + B));
-	t = a + (b - (a + b));
-	
-	if (local_fabs(A) <= local_fabs(B))
-		w = (a + b) + h;
-	else
-		w = (a + b) + H;
-	
-	W = (A + B) + w;
-	Y = (A + B) - W;
-	Y += w;
-	
-	if (local_fabs(a) <= local_fabs(b))
-		w = t + Y;
-	else
-		w = T + Y;
-	
-	dst.s.hi = Y = W + w;
-	dst.s.lo = (W - Y) + w;
-	
-	return dst.ld;
+long double __gcc_qadd(long double x, long double y) {
+  static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+
+  DD dst = {.ld = x}, src = {.ld = y};
+
+  register double A = dst.s.hi, a = dst.s.lo, B = src.s.hi, b = src.s.lo;
+
+  // If both operands are zero:
+  if ((A == 0.0) && (B == 0.0)) {
+    dst.s.hi = A + B;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  // If either operand is NaN or infinity:
+  const doublebits abits = {.d = A};
+  const doublebits bbits = {.d = B};
+  if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
+      (((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
+    dst.s.hi = A + B;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  // If the computation overflows:
+  // This may be playing things a little bit fast and loose, but it will do for
+  // a start.
+  const double testForOverflow = A + (B + (a + b));
+  const doublebits testbits = {.d = testForOverflow};
+  if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
+    dst.s.hi = testForOverflow;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  double H, h;
+  double T, t;
+  double W, w;
+  double Y;
+
+  H = B + (A - (A + B));
+  T = b + (a - (a + b));
+  h = A + (B - (A + B));
+  t = a + (b - (a + b));
+
+  if (local_fabs(A) <= local_fabs(B))
+    w = (a + b) + h;
+  else
+    w = (a + b) + H;
+
+  W = (A + B) + w;
+  Y = (A + B) - W;
+  Y += w;
+
+  if (local_fabs(a) <= local_fabs(b))
+    w = t + Y;
+  else
+    w = T + Y;
+
+  dst.s.hi = Y = W + w;
+  dst.s.lo = (W - Y) + w;
+
+  return dst.ld;
 }
diff --git a/lib/builtins/ppc/gcc_qdiv.c b/lib/builtins/ppc/gcc_qdiv.c
index 70aa00b64400..35a3cbc3d3f8 100644
--- a/lib/builtins/ppc/gcc_qdiv.c
+++ b/lib/builtins/ppc/gcc_qdiv.c
@@ -1,55 +1,52 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __gcc_qdiv(long double x, long double y);
- * This file implements the PowerPC 128-bit double-double division operation.
- * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
- */
+// long double __gcc_qdiv(long double x, long double y);
+// This file implements the PowerPC 128-bit double-double division operation.
+// This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
 
 #include "DD.h"
 
-long double __gcc_qdiv(long double a, long double b)
-{	
-	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
-	DD dst = { .ld = a }, src = { .ld = b };
-	
-	register double x = dst.s.hi, x1 = dst.s.lo,
-					y = src.s.hi, y1 = src.s.lo;
-	
-    double yHi, yLo, qHi, qLo;
-    double yq, tmp, q;
-	
-    q = x / y;
-	
-	/* Detect special cases */
-	if (q == 0.0) {
-		dst.s.hi = q;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	const doublebits qBits = { .d = q };
-	if (((uint32_t)(qBits.x >> 32) & infinityHi) == infinityHi) {
-		dst.s.hi = q;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-    yHi = high26bits(y);
-    qHi = high26bits(q);
-	
-    yq = y * q;
-    yLo = y - yHi;
-    qLo = q - qHi;
-	
-    tmp = LOWORDER(yq, yHi, yLo, qHi, qLo);
-    tmp = (x - yq) - tmp;
-    tmp = ((tmp + x1) - y1 * q) / y;
-    x = q + tmp;
-	
-    dst.s.lo = (q - x) + tmp;
-    dst.s.hi = x;
-	
+long double __gcc_qdiv(long double a, long double b) {
+  static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+  DD dst = {.ld = a}, src = {.ld = b};
+
+  register double x = dst.s.hi, x1 = dst.s.lo, y = src.s.hi, y1 = src.s.lo;
+
+  double yHi, yLo, qHi, qLo;
+  double yq, tmp, q;
+
+  q = x / y;
+
+  // Detect special cases
+  if (q == 0.0) {
+    dst.s.hi = q;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  const doublebits qBits = {.d = q};
+  if (((uint32_t)(qBits.x >> 32) & infinityHi) == infinityHi) {
+    dst.s.hi = q;
+    dst.s.lo = 0.0;
     return dst.ld;
+  }
+
+  yHi = high26bits(y);
+  qHi = high26bits(q);
+
+  yq = y * q;
+  yLo = y - yHi;
+  qLo = q - qHi;
+
+  tmp = LOWORDER(yq, yHi, yLo, qHi, qLo);
+  tmp = (x - yq) - tmp;
+  tmp = ((tmp + x1) - y1 * q) / y;
+  x = q + tmp;
+
+  dst.s.lo = (q - x) + tmp;
+  dst.s.hi = x;
+
+  return dst.ld;
 }
diff --git a/lib/builtins/ppc/gcc_qmul.c b/lib/builtins/ppc/gcc_qmul.c
index fb4c5164ccb5..75f519aad6f0 100644
--- a/lib/builtins/ppc/gcc_qmul.c
+++ b/lib/builtins/ppc/gcc_qmul.c
@@ -1,53 +1,50 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __gcc_qmul(long double x, long double y);
- * This file implements the PowerPC 128-bit double-double multiply operation.
- * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
- */
+// long double __gcc_qmul(long double x, long double y);
+// This file implements the PowerPC 128-bit double-double multiply operation.
+// This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
 
 #include "DD.h"
 
-long double __gcc_qmul(long double x, long double y)
-{	
-	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
-	DD dst = { .ld = x }, src = { .ld = y };
-	
-	register double A = dst.s.hi, a = dst.s.lo,
-					B = src.s.hi, b = src.s.lo;
-	
-	double aHi, aLo, bHi, bLo;
-    double ab, tmp, tau;
-	
-	ab = A * B;
-	
-	/* Detect special cases */
-	if (ab == 0.0) {
-		dst.s.hi = ab;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	const doublebits abBits = { .d = ab };
-	if (((uint32_t)(abBits.x >> 32) & infinityHi) == infinityHi) {
-		dst.s.hi = ab;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	/* Generic cases handled here. */
-    aHi = high26bits(A);
-    bHi = high26bits(B);
-    aLo = A - aHi;
-    bLo = B - bHi;
-	
-    tmp = LOWORDER(ab, aHi, aLo, bHi, bLo);
-    tmp += (A * b + a * B);
-    tau = ab + tmp;
-	
-    dst.s.lo = (ab - tau) + tmp;
-    dst.s.hi = tau;
-	
+long double __gcc_qmul(long double x, long double y) {
+  static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+  DD dst = {.ld = x}, src = {.ld = y};
+
+  register double A = dst.s.hi, a = dst.s.lo, B = src.s.hi, b = src.s.lo;
+
+  double aHi, aLo, bHi, bLo;
+  double ab, tmp, tau;
+
+  ab = A * B;
+
+  // Detect special cases
+  if (ab == 0.0) {
+    dst.s.hi = ab;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  const doublebits abBits = {.d = ab};
+  if (((uint32_t)(abBits.x >> 32) & infinityHi) == infinityHi) {
+    dst.s.hi = ab;
+    dst.s.lo = 0.0;
     return dst.ld;
+  }
+
+  // Generic cases handled here.
+  aHi = high26bits(A);
+  bHi = high26bits(B);
+  aLo = A - aHi;
+  bLo = B - bHi;
+
+  tmp = LOWORDER(ab, aHi, aLo, bHi, bLo);
+  tmp += (A * b + a * B);
+  tau = ab + tmp;
+
+  dst.s.lo = (ab - tau) + tmp;
+  dst.s.hi = tau;
+
+  return dst.ld;
 }
diff --git a/lib/builtins/ppc/gcc_qsub.c b/lib/builtins/ppc/gcc_qsub.c
index c092e24dbda1..ac08120be0bd 100644
--- a/lib/builtins/ppc/gcc_qsub.c
+++ b/lib/builtins/ppc/gcc_qsub.c
@@ -1,76 +1,74 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-/* long double __gcc_qsub(long double x, long double y);
- * This file implements the PowerPC 128-bit double-double add operation.
- * This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
- */
+// long double __gcc_qsub(long double x, long double y);
+// This file implements the PowerPC 128-bit double-double add operation.
+// This implementation is shamelessly cribbed from Apple's DDRT, circa 1993(!)
 
 #include "DD.h"
 
-long double __gcc_qsub(long double x, long double y)
-{
-	static const uint32_t infinityHi = UINT32_C(0x7ff00000);
-	
-	DD dst = { .ld = x }, src = { .ld = y };
-	
-	register double A =  dst.s.hi, a =  dst.s.lo,
-					B = -src.s.hi, b = -src.s.lo;
-	
-	/* If both operands are zero: */
-	if ((A == 0.0) && (B == 0.0)) {
-		dst.s.hi = A + B;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	/* If either operand is NaN or infinity: */
-	const doublebits abits = { .d = A };
-	const doublebits bbits = { .d = B };
-	if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
-		(((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
-		dst.s.hi = A + B;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	/* If the computation overflows: */
-	/* This may be playing things a little bit fast and loose, but it will do for a start. */
-	const double testForOverflow = A + (B + (a + b));
-	const doublebits testbits = { .d = testForOverflow };
-	if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
-		dst.s.hi = testForOverflow;
-		dst.s.lo = 0.0;
-		return dst.ld;
-	}
-	
-	double H, h;
-	double T, t;
-	double W, w;
-	double Y;
-	
-	H = B + (A - (A + B));
-	T = b + (a - (a + b));
-	h = A + (B - (A + B));
-	t = a + (b - (a + b));
-	
-	if (local_fabs(A) <= local_fabs(B))
-		w = (a + b) + h;
-	else
-		w = (a + b) + H;
-	
-	W = (A + B) + w;
-	Y = (A + B) - W;
-	Y += w;
-	
-	if (local_fabs(a) <= local_fabs(b))
-		w = t + Y;
-	else
-		w = T + Y;
-	
-	dst.s.hi = Y = W + w;
-	dst.s.lo = (W - Y) + w;
-	
-	return dst.ld;
+long double __gcc_qsub(long double x, long double y) {
+  static const uint32_t infinityHi = UINT32_C(0x7ff00000);
+
+  DD dst = {.ld = x}, src = {.ld = y};
+
+  register double A = dst.s.hi, a = dst.s.lo, B = -src.s.hi, b = -src.s.lo;
+
+  // If both operands are zero:
+  if ((A == 0.0) && (B == 0.0)) {
+    dst.s.hi = A + B;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  // If either operand is NaN or infinity:
+  const doublebits abits = {.d = A};
+  const doublebits bbits = {.d = B};
+  if ((((uint32_t)(abits.x >> 32) & infinityHi) == infinityHi) ||
+      (((uint32_t)(bbits.x >> 32) & infinityHi) == infinityHi)) {
+    dst.s.hi = A + B;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  // If the computation overflows:
+  // This may be playing things a little bit fast and loose, but it will do for
+  // a start.
+  const double testForOverflow = A + (B + (a + b));
+  const doublebits testbits = {.d = testForOverflow};
+  if (((uint32_t)(testbits.x >> 32) & infinityHi) == infinityHi) {
+    dst.s.hi = testForOverflow;
+    dst.s.lo = 0.0;
+    return dst.ld;
+  }
+
+  double H, h;
+  double T, t;
+  double W, w;
+  double Y;
+
+  H = B + (A - (A + B));
+  T = b + (a - (a + b));
+  h = A + (B - (A + B));
+  t = a + (b - (a + b));
+
+  if (local_fabs(A) <= local_fabs(B))
+    w = (a + b) + h;
+  else
+    w = (a + b) + H;
+
+  W = (A + B) + w;
+  Y = (A + B) - W;
+  Y += w;
+
+  if (local_fabs(a) <= local_fabs(b))
+    w = t + Y;
+  else
+    w = T + Y;
+
+  dst.s.hi = Y = W + w;
+  dst.s.lo = (W - Y) + w;
+
+  return dst.ld;
 }
diff --git a/lib/builtins/ppc/multc3.c b/lib/builtins/ppc/multc3.c
index 9dd79c975dde..f1fd6816d6c8 100644
--- a/lib/builtins/ppc/multc3.c
+++ b/lib/builtins/ppc/multc3.c
@@ -1,90 +1,85 @@
-/* This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
- */
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "DD.h"
 #include "../int_math.h"
+#include "DD.h"
 
-#define makeFinite(x) { \
-    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi); \
-    (x).s.lo = 0.0;                                                     \
+#define makeFinite(x)                                                          \
+  {                                                                            \
+    (x).s.hi = crt_copysign(crt_isinf((x).s.hi) ? 1.0 : 0.0, (x).s.hi);        \
+    (x).s.lo = 0.0;                                                            \
   }
 
-#define zeroNaN(x) { \
-    if (crt_isnan((x).s.hi)) {                                          \
-      (x).s.hi = crt_copysign(0.0, (x).s.hi);                     \
-      (x).s.lo = 0.0;                                                   \
-    }                                                                   \
+#define zeroNaN(x)                                                             \
+  {                                                                            \
+    if (crt_isnan((x).s.hi)) {                                                 \
+      (x).s.hi = crt_copysign(0.0, (x).s.hi);                                  \
+      (x).s.lo = 0.0;                                                          \
+    }                                                                          \
   }
 
-long double _Complex
-__multc3(long double a, long double b, long double c, long double d)
-{
-	long double ac = __gcc_qmul(a,c);
-	long double bd = __gcc_qmul(b,d);
-	long double ad = __gcc_qmul(a,d);
-	long double bc = __gcc_qmul(b,c);
-	
-	DD real = { .ld = __gcc_qsub(ac,bd) };
-	DD imag = { .ld = __gcc_qadd(ad,bc) };
-	
-	if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi))
-	{
-		int recalc = 0;
-		
-		DD aDD = { .ld = a };
-		DD bDD = { .ld = b };
-		DD cDD = { .ld = c };
-		DD dDD = { .ld = d };
-		
-		if (crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi))
-		{
-			makeFinite(aDD);
-			makeFinite(bDD);
-			zeroNaN(cDD);
-			zeroNaN(dDD);
-			recalc = 1;
-		}
-		
-		if (crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi))
-		{
-			makeFinite(cDD);
-			makeFinite(dDD);
-			zeroNaN(aDD);
-			zeroNaN(bDD);
-			recalc = 1;
-		}
-		
-		if (!recalc)
-		{
-			DD acDD = { .ld = ac };
-			DD bdDD = { .ld = bd };
-			DD adDD = { .ld = ad };
-			DD bcDD = { .ld = bc };
-			
-			if (crt_isinf(acDD.s.hi) || crt_isinf(bdDD.s.hi) ||
-                            crt_isinf(adDD.s.hi) || crt_isinf(bcDD.s.hi))
-			{
-				zeroNaN(aDD);
-				zeroNaN(bDD);
-				zeroNaN(cDD);
-				zeroNaN(dDD);
-				recalc = 1;
-			}
-		}
-		
-		if (recalc)
-		{
-			real.s.hi = CRT_INFINITY * (aDD.s.hi*cDD.s.hi - bDD.s.hi*dDD.s.hi);
-			real.s.lo = 0.0;
-			imag.s.hi = CRT_INFINITY * (aDD.s.hi*dDD.s.hi + bDD.s.hi*cDD.s.hi);
-			imag.s.lo = 0.0;
-		}
-	}
-	
-	long double _Complex z;
-	__real__ z = real.ld;
-	__imag__ z = imag.ld;
-	
-	return z;
+long double _Complex __multc3(long double a, long double b, long double c,
+                              long double d) {
+  long double ac = __gcc_qmul(a, c);
+  long double bd = __gcc_qmul(b, d);
+  long double ad = __gcc_qmul(a, d);
+  long double bc = __gcc_qmul(b, c);
+
+  DD real = {.ld = __gcc_qsub(ac, bd)};
+  DD imag = {.ld = __gcc_qadd(ad, bc)};
+
+  if (crt_isnan(real.s.hi) && crt_isnan(imag.s.hi)) {
+    int recalc = 0;
+
+    DD aDD = {.ld = a};
+    DD bDD = {.ld = b};
+    DD cDD = {.ld = c};
+    DD dDD = {.ld = d};
+
+    if (crt_isinf(aDD.s.hi) || crt_isinf(bDD.s.hi)) {
+      makeFinite(aDD);
+      makeFinite(bDD);
+      zeroNaN(cDD);
+      zeroNaN(dDD);
+      recalc = 1;
+    }
+
+    if (crt_isinf(cDD.s.hi) || crt_isinf(dDD.s.hi)) {
+      makeFinite(cDD);
+      makeFinite(dDD);
+      zeroNaN(aDD);
+      zeroNaN(bDD);
+      recalc = 1;
+    }
+
+    if (!recalc) {
+      DD acDD = {.ld = ac};
+      DD bdDD = {.ld = bd};
+      DD adDD = {.ld = ad};
+      DD bcDD = {.ld = bc};
+
+      if (crt_isinf(acDD.s.hi) || crt_isinf(bdDD.s.hi) ||
+          crt_isinf(adDD.s.hi) || crt_isinf(bcDD.s.hi)) {
+        zeroNaN(aDD);
+        zeroNaN(bDD);
+        zeroNaN(cDD);
+        zeroNaN(dDD);
+        recalc = 1;
+      }
+    }
+
+    if (recalc) {
+      real.s.hi = CRT_INFINITY * (aDD.s.hi * cDD.s.hi - bDD.s.hi * dDD.s.hi);
+      real.s.lo = 0.0;
+      imag.s.hi = CRT_INFINITY * (aDD.s.hi * dDD.s.hi + bDD.s.hi * cDD.s.hi);
+      imag.s.lo = 0.0;
+    }
+  }
+
+  long double _Complex z;
+  __real__ z = real.ld;
+  __imag__ z = imag.ld;
+
+  return z;
 }
diff --git a/lib/builtins/ppc/restFP.S b/lib/builtins/ppc/restFP.S
index 507e756e18b1..02317bd6a649 100644
--- a/lib/builtins/ppc/restFP.S
+++ b/lib/builtins/ppc/restFP.S
@@ -1,9 +1,8 @@
 //===-- restFP.S - Implement restFP ---------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/lib/builtins/ppc/saveFP.S b/lib/builtins/ppc/saveFP.S
index 20b06fff53d9..1ef5532c8a83 100644
--- a/lib/builtins/ppc/saveFP.S
+++ b/lib/builtins/ppc/saveFP.S
@@ -1,9 +1,8 @@
 //===-- saveFP.S - Implement saveFP ---------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//