[libc] apply new lint rules

[michaelrj]

Summary

This patch applies the lint rules described in the previous patch. There
was also a significant amount of effort put into manually fixing things,
since all of the templated functions, or structs defined in /spec, were
not updated and had to be handled manually.

[lntue]

libc/src/__support/CPP/TypeTraits.h

34 ↗

(On Diff #388670)

If we are going to change these, I feel like changing to match std::is_same_v style for these templates would be more beneficial.

libc/src/__support/detailed_powers_of_ten.h

34

Can this one be all CAPS?

[sivachandra]

In general looks good. Please ping after updating the commit message and fixing the broken tests.

libc/src/__support/CPP/TypeTraits.h

34 ↗

(On Diff #388670)

We should have a consistent style. So, I am inclined towards IS_SAME_V and fix the other constants/constexpr values to follow this style.

libc/src/__support/detailed_powers_of_ten.h

34

Yes, for consistency.

[michaelrj]

rebase and a bit more clean up.

I also looked into the sigaction failure, and it appears to be caused by raise(SIGUSR1) segfaulting, although I'm not sure why.

libc/src/__support/detailed_powers_of_ten.h

34

I changed it to constexpr so that the lint rules would make it caps

[michaelrj]

fix the signal problems, also update the lint rules.

[gchatelet]

Quick comments after glancing at the change

libc/src/__support/CPP/TypeTraits.h

46–53 ↗

(On Diff #390864)

Uppercase template member fields is very counter intuitive. I don't think I've seen this in any of the llvm projects.

libc/src/string/memmove.cpp

43

This memmove implementation is stale (it's been updated)

[michaelrj]

ARM fixes (except for memory_utils, which needs discussion)

[michaelrj]

fix some formatting changes that were unnecessary (specifically reverting struct tm -> struct Tm and the TypeTraits.h changes)

[gchatelet]

In D114302#3165611, @michaelrj wrote:

fix some formatting changes that were unnecessary (specifically reverting struct tm -> struct Tm and the TypeTraits.h changes)

Thx it feels much more natural.

[gchatelet]

libc/src/string/memory_utils/elements.h

89

Actually, now that it's uppercased there's no need for the K_, it could just be SIZE.
I'm a bit concerned that the constexpr variable really look and feel like a MACRO now.
I liked the visual hint that it was a typed variable and not something that the preprocessor might control.
@sivachandra WDYT?

libc/src/string/memory_utils/memcpy_implementations.h

49

Same here in this file, no need for the K_.

[michaelrj]

Fix most of the Arm stuff (still needs testing)

[michaelrj]

final arm fixes

[lntue]

libc/src/math/generic/sincosf_data.cpp

18

This constant table is in float, so constexpr won't work. Is there any simple way to make this all caps?

45

INV_PIO4

[michaelrj]

Fix specific requested variables

libc/src/math/generic/sincosf_data.cpp

18

I solved this by adding an exception for variables starting with underscores, so if you want to have a variable with any case you want, it just has to start with an underscore.

[michaelrj]

rebase in prep for pushing

[sivachandra]

Accepting now. With a change this large, I am sure some of the corners will go in unpolished. We can fix them up as we notice in follow up patches. As long as we have the correct clang-tidy rules checked in, we are good to go.

[michaelrj]

update with changes from adjusted lint rules

[michaelrj]

rebase before landing

libc/benchmarks/automemcpy/lib/CodeGen.cpp

 // This namespace turns a NamedFunctionDescriptor into an actual implementation.
 // -----------------------------------------------------------------------------
 // e.g.
 // static void memcpy_0xB20D4702493C397E(char *__restrict dst,
 //                                       const char *__restrict src,
 //                                       size_t size) {
 //   using namespace __llvm_libc::x86;
 //   if(size == 0) return;
-//   if(size == 1) return Copy<_1>(dst, src);
-//   if(size < 4) return Copy<HeadTail<_2>>(dst, src, size);
-//   if(size < 8) return Copy<HeadTail<_4>>(dst, src, size);
-//   if(size < 16) return Copy<HeadTail<_8>>(dst, src, size);
-//   if(size < 32) return Copy<HeadTail<_16>>(dst, src, size);
-//   return Copy<Accelerator>(dst, src, size);
+//   if(size == 1) return copy<_1>(dst, src);
+//   if(size < 4) return copy<HeadTail<_2>>(dst, src, size);
+//   if(size < 8) return copy<HeadTail<_4>>(dst, src, size);
+//   if(size < 16) return copy<HeadTail<_8>>(dst, src, size);
+//   if(size < 32) return copy<HeadTail<_16>>(dst, src, size);
+//   return copy<Accelerator>(dst, src, size);
 // }
 
 // The `Serialize` method turns a `NamedFunctionDescriptor` into a
 // `FunctionImplementation` which holds all the information needed to produce
 // the C++ source code.
 
 // An Element with its size (e.g. `_16` in the example above).
 struct ElementType {

 // The accelerator strategy.
 struct Accelerator {
   size_t IfLt;
 };
 // The Context stores data about the function type.
 struct Context {
   StringRef FunctionReturnType; // e.g. void* or int
   StringRef FunctionArgs;
-  StringRef ElementOp; // Copy, ThreeWayCompare, SplatSet, ...
+  StringRef ElementOp; // copy, three_way_compare, splat_set, ...
   StringRef FixedSizeArgs;
   StringRef RuntimeSizeArgs;
   StringRef AlignArg1;
   StringRef AlignArg2;
   StringRef DefaultReturnValue;
 };
 // A detailed representation of the function implementation mapped from the
 // NamedFunctionDescriptor.

 };
 
 // Returns the Context for each FunctionType.
 static Context getCtx(FunctionType FT) {
   switch (FT) {
   case FunctionType::MEMCPY:
     return {"void",
             "(char *__restrict dst, const char *__restrict src, size_t size)",
-            "Copy",
+            "copy",
             "(dst, src)",
             "(dst, src, size)",
             "Arg::Dst",
             "Arg::Src",
             ""};
   case FunctionType::MEMCMP:
     return {"int",
             "(const char * lhs, const char * rhs, size_t size)",
-            "ThreeWayCompare",
+            "three_way_compare",
             "(lhs, rhs)",
             "(lhs, rhs, size)",
             "Arg::Lhs",
             "Arg::Rhs",
             "0"};
   case FunctionType::MEMSET:
     return {"void",
             "(char * dst, int value, size_t size)",
-            "SplatSet",
+            "splat_set",
             "(dst, value)",
             "(dst, value, size)",
             "Arg::Dst",
             "Arg::Src",
             ""};
   case FunctionType::BZERO:
     return {"void",           "(char * dst, size_t size)",
-            "SplatSet",       "(dst, 0)",
+            "splat_set",      "(dst, 0)",
             "(dst, 0, size)", "Arg::Dst",
             "Arg::Src",       ""};
   default:
     report_fatal_error("Not yet implemented");
   }
 }
 
 static StringRef getAligntoString(const Context &Ctx, const AlignArg &AlignTo) {

libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp

 using llvm::libc_benchmarks::MemcmpOrBcmpConfiguration;
 using llvm::libc_benchmarks::MemcpyConfiguration;
 using llvm::libc_benchmarks::MemsetConfiguration;
 
 namespace __llvm_libc {
 
 static void memcpy_0xE00E29EE73994E2B(char *__restrict dst, const char *__restrict src, size_t size) {
   using namespace __llvm_libc::x86;
-  return Copy<Accelerator>(dst, src, size);
+  return copy<Accelerator>(dst, src, size);
 }
 static void memcpy_0x7381B60C7BE75EF9(char *__restrict dst, const char *__restrict src, size_t size) {
   using namespace __llvm_libc::x86;
   if(size == 0) return;
-  if(size == 1) return Copy<_1>(dst, src);
-  if(size == 2) return Copy<_2>(dst, src);
-  if(size == 3) return Copy<_3>(dst, src);
-  if(size < 8) return Copy<HeadTail<_4>>(dst, src, size);
-  if(size < 16) return Copy<HeadTail<_8>>(dst, src, size);
-  if(size < 32) return Copy<HeadTail<_16>>(dst, src, size);
-  if(size < 64) return Copy<HeadTail<_32>>(dst, src, size);
-  if(size < 128) return Copy<HeadTail<_64>>(dst, src, size);
-  if(size < 256) return Copy<HeadTail<_128>>(dst, src, size);
-  return Copy<Loop<_64>>(dst, src, size);
+  if(size == 1) return copy<_1>(dst, src);
+  if(size == 2) return copy<_2>(dst, src);
+  if(size == 3) return copy<_3>(dst, src);
+  if(size < 8) return copy<HeadTail<_4>>(dst, src, size);
+  if(size < 16) return copy<HeadTail<_8>>(dst, src, size);
+  if(size < 32) return copy<HeadTail<_16>>(dst, src, size);
+  if(size < 64) return copy<HeadTail<_32>>(dst, src, size);
+  if(size < 128) return copy<HeadTail<_64>>(dst, src, size);
+  if(size < 256) return copy<HeadTail<_128>>(dst, src, size);
+  return copy<Loop<_64>>(dst, src, size);
 }
 static int memcmp_0x348D7BA6DB0EE033(const char * lhs, const char * rhs, size_t size) {
   using namespace __llvm_libc::x86;
   if(size == 0) return 0;
-  if(size == 1) return ThreeWayCompare<_1>(lhs, rhs);
-  if(size < 4) return ThreeWayCompare<HeadTail<_2>>(lhs, rhs, size);
-  if(size < 8) return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, size);
-  if(size < 16) return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, size);
-  if(size < 32) return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, size);
-  if(size < 64) return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, size);
-  return ThreeWayCompare<Align<_16,Arg::Lhs>::Then<Loop<_16>>>(lhs, rhs, size);
+  if(size == 1) return three_way_compare<_1>(lhs, rhs);
+  if(size < 4) return three_way_compare<HeadTail<_2>>(lhs, rhs, size);
+  if(size < 8) return three_way_compare<HeadTail<_4>>(lhs, rhs, size);
+  if(size < 16) return three_way_compare<HeadTail<_8>>(lhs, rhs, size);
+  if(size < 32) return three_way_compare<HeadTail<_16>>(lhs, rhs, size);
+  if(size < 64) return three_way_compare<HeadTail<_32>>(lhs, rhs, size);
+  return three_way_compare<Align<_16,Arg::Lhs>::Then<Loop<_16>>>(lhs, rhs, size);
 }
 static void memset_0x71E761699B999863(char * dst, int value, size_t size) {
   using namespace __llvm_libc::x86;
   if(size == 0) return;
-  if(size == 1) return SplatSet<_1>(dst, value);
-  if(size < 4) return SplatSet<HeadTail<_2>>(dst, value, size);
-  if(size < 8) return SplatSet<HeadTail<_4>>(dst, value, size);
-  if(size < 16) return SplatSet<HeadTail<_8>>(dst, value, size);
-  if(size < 32) return SplatSet<HeadTail<_16>>(dst, value, size);
-  if(size < 64) return SplatSet<HeadTail<_32>>(dst, value, size);
-  if(size < 128) return SplatSet<HeadTail<_64>>(dst, value, size);
-  if(size < 256) return SplatSet<HeadTail<_128>>(dst, value, size);
-  return SplatSet<Align<_16,Arg::Dst>::Then<Loop<_32>>>(dst, value, size);
+  if(size == 1) return splat_set<_1>(dst, value);
+  if(size < 4) return splat_set<HeadTail<_2>>(dst, value, size);
+  if(size < 8) return splat_set<HeadTail<_4>>(dst, value, size);
+  if(size < 16) return splat_set<HeadTail<_8>>(dst, value, size);
+  if(size < 32) return splat_set<HeadTail<_16>>(dst, value, size);
+  if(size < 64) return splat_set<HeadTail<_32>>(dst, value, size);
+  if(size < 128) return splat_set<HeadTail<_64>>(dst, value, size);
+  if(size < 256) return splat_set<HeadTail<_128>>(dst, value, size);
+  return splat_set<Align<_16,Arg::Dst>::Then<Loop<_32>>>(dst, value, size);
 }
 static void memset_0x3DF0F44E2ED6A50F(char * dst, int value, size_t size) {
   using namespace __llvm_libc::x86;
   if(size == 0) return;
-  if(size == 1) return SplatSet<_1>(dst, value);
-  if(size < 4) return SplatSet<HeadTail<_2>>(dst, value, size);
-  if(size < 8) return SplatSet<HeadTail<_4>>(dst, value, size);
-  if(size < 16) return SplatSet<HeadTail<_8>>(dst, value, size);
-  if(size < 32) return SplatSet<HeadTail<_16>>(dst, value, size);
-  if(size < 64) return SplatSet<HeadTail<_32>>(dst, value, size);
-  if(size < 128) return SplatSet<HeadTail<_64>>(dst, value, size);
-  if(size < 256) return SplatSet<HeadTail<_128>>(dst, value, size);
-  return SplatSet<Align<_32,Arg::Dst>::Then<Loop<_32>>>(dst, value, size);
+  if(size == 1) return splat_set<_1>(dst, value);
+  if(size < 4) return splat_set<HeadTail<_2>>(dst, value, size);
+  if(size < 8) return splat_set<HeadTail<_4>>(dst, value, size);
+  if(size < 16) return splat_set<HeadTail<_8>>(dst, value, size);
+  if(size < 32) return splat_set<HeadTail<_16>>(dst, value, size);
+  if(size < 64) return splat_set<HeadTail<_32>>(dst, value, size);
+  if(size < 128) return splat_set<HeadTail<_64>>(dst, value, size);
+  if(size < 256) return splat_set<HeadTail<_128>>(dst, value, size);
+  return splat_set<Align<_32,Arg::Dst>::Then<Loop<_32>>>(dst, value, size);
 }
 static void bzero_0x475977492C218AD4(char * dst, size_t size) {
   using namespace __llvm_libc::x86;
   if(size == 0) return;
-  if(size == 1) return SplatSet<_1>(dst, 0);
-  if(size == 2) return SplatSet<_2>(dst, 0);
-  if(size == 3) return SplatSet<_3>(dst, 0);
-  if(size < 8) return SplatSet<HeadTail<_4>>(dst, 0, size);
-  if(size < 16) return SplatSet<HeadTail<_8>>(dst, 0, size);
-  if(size < 32) return SplatSet<HeadTail<_16>>(dst, 0, size);
-  if(size < 64) return SplatSet<HeadTail<_32>>(dst, 0, size);
-  if(size < 128) return SplatSet<HeadTail<_64>>(dst, 0, size);
-  return SplatSet<Align<_32,Arg::Dst>::Then<Loop<_32>>>(dst, 0, size);
+  if(size == 1) return splat_set<_1>(dst, 0);
+  if(size == 2) return splat_set<_2>(dst, 0);
+  if(size == 3) return splat_set<_3>(dst, 0);
+  if(size < 8) return splat_set<HeadTail<_4>>(dst, 0, size);
+  if(size < 16) return splat_set<HeadTail<_8>>(dst, 0, size);
+  if(size < 32) return splat_set<HeadTail<_16>>(dst, 0, size);
+  if(size < 64) return splat_set<HeadTail<_32>>(dst, 0, size);
+  if(size < 128) return splat_set<HeadTail<_64>>(dst, 0, size);
+  return splat_set<Align<_32,Arg::Dst>::Then<Loop<_32>>>(dst, 0, size);
 }
 
 } // namespace __llvm_libc
 
 namespace llvm {
 namespace automemcpy {
 
 ArrayRef<NamedFunctionDescriptor> getFunctionDescriptors() {

libc/fuzzing/math/Compare.h

 
 template <typename T>
 __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value,
                                bool>
 ValuesEqual(T x1, T x2) {
   __llvm_libc::fputil::FPBits<T> bits1(x1);
   __llvm_libc::fputil::FPBits<T> bits2(x2);
   // If either is NaN, we want both to be NaN.
-  if (bits1.isNaN() || bits2.isNaN())
-    return bits2.isNaN() && bits2.isNaN();
+  if (bits1.is_nan() || bits2.is_nan())
+    return bits2.is_nan() && bits2.is_nan();
 
   // For all other values, we want the values to be bitwise equal.
   return bits1.uintval() == bits2.uintval();
 }
 
 template <typename T>
 __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsIntegral<T>::Value, bool>
 ValuesEqual(T x1, T x2) {
   return x1 == x1;
 }
 
 #endif // LLVM_LIBC_FUZZING_MATH_COMPARE_H

libc/src/__support/CPP/Bitset.h

 namespace __llvm_libc {
 namespace cpp {
 
 template <size_t NumberOfBits> struct Bitset {
   static_assert(NumberOfBits != 0,
                 "Cannot create a __llvm_libc::cpp::Bitset of size 0.");
 
   constexpr void set(size_t Index) {
-    Data[Index / BitsPerUnit] |= (uintptr_t{1} << (Index % BitsPerUnit));
+    Data[Index / BITS_PER_UNIT] |= (uintptr_t{1} << (Index % BITS_PER_UNIT));
   }
 
   constexpr bool test(size_t Index) const {
-    return Data[Index / BitsPerUnit] & (uintptr_t{1} << (Index % BitsPerUnit));
+    return Data[Index / BITS_PER_UNIT] &
+           (uintptr_t{1} << (Index % BITS_PER_UNIT));
   }
 
 private:
-  static constexpr size_t BitsPerByte = 8;
-  static constexpr size_t BitsPerUnit = BitsPerByte * sizeof(uintptr_t);
-  uintptr_t Data[(NumberOfBits + BitsPerUnit - 1) / BitsPerUnit] = {0};
+  static constexpr size_t BITS_PER_BYTE = 8;
+  static constexpr size_t BITS_PER_UNIT = BITS_PER_BYTE * sizeof(uintptr_t);
+  uintptr_t Data[(NumberOfBits + BITS_PER_UNIT - 1) / BITS_PER_UNIT] = {0};
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H

libc/src/__support/FPUtil/BasicOperations.h

 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T abs(T x) {
   FPBits<T> bits(x);
-  bits.setSign(0);
+  bits.set_sign(0);
   return T(bits);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fmin(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
-  if (bitx.isNaN()) {
+  if (bitx.is_nan()) {
     return y;
-  } else if (bity.isNaN()) {
+  } else if (bity.is_nan()) {
     return x;
-  } else if (bitx.getSign() != bity.getSign()) {
+  } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmin(+0, -0) == -0 == fmin(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with negative sign.
-    return (bitx.getSign() ? x : y);
+    return (bitx.get_sign() ? x : y);
   } else {
     return (x < y ? x : y);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fmax(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
-  if (bitx.isNaN()) {
+  if (bitx.is_nan()) {
     return y;
-  } else if (bity.isNaN()) {
+  } else if (bity.is_nan()) {
     return x;
-  } else if (bitx.getSign() != bity.getSign()) {
+  } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmax(+0, -0) == +0 == fmax(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with positive sign.
-    return (bitx.getSign() ? y : x);
+    return (bitx.get_sign() ? y : x);
   } else {
     return (x > y ? x : y);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T fdim(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
-  if (bitx.isNaN()) {
+  if (bitx.is_nan()) {
     return x;
   }
 
-  if (bity.isNaN()) {
+  if (bity.is_nan()) {
     return y;
   }
 
   return (x > y ? x - y : 0);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

 #include "ManipulationFunctions.h"
 #include "NormalFloat.h"
 
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-static constexpr int quotientLSBBits = 3;
+static constexpr int QUOTIENT_LSB_BITS = 3;
 
 // The implementation is a bit-by-bit algorithm which uses integer division
 // to evaluate the quotient and remainder.
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T remquo(T x, T y, int &q) {
   FPBits<T> xbits(x), ybits(y);
-  if (xbits.isNaN())
+  if (xbits.is_nan())
     return x;
-  if (ybits.isNaN())
+  if (ybits.is_nan())
     return y;
-  if (xbits.isInf() || ybits.isZero())
-    return FPBits<T>::buildNaN(1);
+  if (xbits.is_inf() || ybits.is_zero())
+    return FPBits<T>::build_nan(1);
 
-  if (xbits.isZero()) {
+  if (xbits.is_zero()) {
     q = 0;
     return __llvm_libc::fputil::copysign(T(0.0), x);
   }
 
-  if (ybits.isInf()) {
+  if (ybits.is_inf()) {
     q = 0;
     return x;
   }
 
-  bool resultSign = (xbits.getSign() == ybits.getSign() ? false : true);
+  bool result_sign = (xbits.get_sign() == ybits.get_sign() ? false : true);
 
   // Once we know the sign of the result, we can just operate on the absolute
   // values. The correct sign can be applied to the result after the result
   // is evaluated.
-  xbits.setSign(0);
-  ybits.setSign(0);
+  xbits.set_sign(0);
+  ybits.set_sign(0);
 
   NormalFloat<T> normalx(xbits), normaly(ybits);
   int exp = normalx.exponent - normaly.exponent;
   typename NormalFloat<T>::UIntType mx = normalx.mantissa,
                                     my = normaly.mantissa;
 
   q = 0;
   while (exp >= 0) {
-    unsigned shiftCount = 0;
+    unsigned shift_count = 0;
     typename NormalFloat<T>::UIntType n = mx;
-    for (shiftCount = 0; n < my; n <<= 1, ++shiftCount)
+    for (shift_count = 0; n < my; n <<= 1, ++shift_count)
       ;
 
-    if (static_cast<int>(shiftCount) > exp)
+    if (static_cast<int>(shift_count) > exp)
       break;
 
-    exp -= shiftCount;
-    if (0 <= exp && exp < quotientLSBBits)
+    exp -= shift_count;
+    if (0 <= exp && exp < QUOTIENT_LSB_BITS)
       q |= (1 << exp);
 
     mx = n - my;
     if (mx == 0) {
-      q = resultSign ? -q : q;
+      q = result_sign ? -q : q;
       return __llvm_libc::fputil::copysign(T(0.0), x);
     }
   }
 
   NormalFloat<T> remainder(exp + normaly.exponent, mx, 0);
 
   // Since NormalFloat to native type conversion is a truncation operation
   // currently, the remainder value in the native type is correct as is.
   // However, if NormalFloat to native type conversion is updated in future,
   // then the conversion to native remainder value should be updated
   // appropriately and some directed tests added.
-  T nativeRemainder(remainder);
+  T native_remainder(remainder);
   T absy = T(ybits);
   int cmp = remainder.mul2(1).cmp(normaly);
   if (cmp > 0) {
     q = q + 1;
     if (x >= T(0.0))
-      nativeRemainder = nativeRemainder - absy;
+      native_remainder = native_remainder - absy;
     else
-      nativeRemainder = absy - nativeRemainder;
+      native_remainder = absy - native_remainder;
   } else if (cmp == 0) {
     if (q & 1) {
       q += 1;
       if (x >= T(0.0))
-        nativeRemainder = -nativeRemainder;
+        native_remainder = -native_remainder;
     } else {
       if (x < T(0.0))
-        nativeRemainder = -nativeRemainder;
+        native_remainder = -native_remainder;
     }
   } else {
     if (x < T(0.0))
-      nativeRemainder = -nativeRemainder;
+      native_remainder = -native_remainder;
   }
 
-  q = resultSign ? -q : q;
-  if (nativeRemainder == T(0.0))
+  q = result_sign ? -q : q;
+  if (native_remainder == T(0.0))
     return __llvm_libc::fputil::copysign(T(0.0), x);
-  return nativeRemainder;
+  return native_remainder;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H

libc/src/__support/FPUtil/FEnvImpl.h

 #include <fenv.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // All dummy functions silently succeed.
 
-static inline int clearExcept(int) { return 0; }
+static inline int clear_except(int) { return 0; }
 
-static inline int testExcept(int) { return 0; }
+static inline int test_except(int) { return 0; }
 
-static inline int setExcept(int) { return 0; }
+static inline int set_except(int) { return 0; }
 
-static inline int raiseExcept(int) { return 0; }
+static inline int raise_except(int) { return 0; }
 
-static inline int getRound() { return FE_TONEAREST; }
+static inline int get_round() { return FE_TONEAREST; }
 
-static inline int setRound(int) { return 0; }
+static inline int set_round(int) { return 0; }
 
-static inline int getEnv(fenv_t *) { return 0; }
+static inline int get_env(fenv_t *) { return 0; }
 
-static inline int setEnv(const fenv_t *) { return 0; }
+static inline int set_env(const fenv_t *) { return 0; }
 
 } // namespace fputil
 } // namespace __llvm_libc
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_H

libc/src/__support/FPUtil/FPBits.h

 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct MantissaWidth {
-  static constexpr unsigned value = FloatProperties<T>::mantissaWidth;
+  static constexpr unsigned VALUE = FloatProperties<T>::MANTISSA_WIDTH;
 };
 
 template <typename T> struct ExponentWidth {
-  static constexpr unsigned value = FloatProperties<T>::exponentWidth;
+  static constexpr unsigned VALUE = FloatProperties<T>::EXPONENT_WIDTH;
 };
 
 // A generic class to represent single precision, double precision, and quad
 // precision IEEE 754 floating point formats.
 // On most platforms, the 'float' type corresponds to single precision floating
 // point numbers, the 'double' type corresponds to double precision floating
 // point numers, and the 'long double' type corresponds to the quad precision
 // floating numbers. On x86 platforms however, the 'long double' type maps to
 // an x87 floating point format. This format is an IEEE 754 extension format.
 // It is handled as an explicit specialization of this class.
 template <typename T> union FPBits {
   static_assert(cpp::IsFloatingPointType<T>::Value,
                 "FPBits instantiated with invalid type.");
 
   // Reinterpreting bits as an integer value and interpreting the bits of an
   // integer value as a floating point value is used in tests. So, a convenient
   // type is provided for such reinterpretations.
   using FloatProp = FloatProperties<T>;
   // TODO: Change UintType name to BitsType for consistency.
   using UIntType = typename FloatProp::BitsType;
 
   UIntType bits;
 
-  void setMantissa(UIntType mantVal) {
-    mantVal &= (FloatProp::mantissaMask);
-    bits &= ~(FloatProp::mantissaMask);
+  void set_mantissa(UIntType mantVal) {
+    mantVal &= (FloatProp::MANTISSA_MASK);
+    bits &= ~(FloatProp::MANTISSA_MASK);
     bits |= mantVal;
   }
 
-  UIntType getMantissa() const { return bits & FloatProp::mantissaMask; }
+  UIntType get_mantissa() const { return bits & FloatProp::MANTISSA_MASK; }
 
-  void setUnbiasedExponent(UIntType expVal) {
-    expVal = (expVal << (FloatProp::mantissaWidth)) & FloatProp::exponentMask;
-    bits &= ~(FloatProp::exponentMask);
+  void set_unbiased_exponent(UIntType expVal) {
+    expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
+    bits &= ~(FloatProp::EXPONENT_MASK);
     bits |= expVal;
   }
 
-  uint16_t getUnbiasedExponent() const {
-    return uint16_t((bits & FloatProp::exponentMask) >>
-                    (FloatProp::mantissaWidth));
+  uint16_t get_unbiased_exponent() const {
+    return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
+                    (FloatProp::MANTISSA_WIDTH));
   }
 
-  void setSign(bool signVal) {
-    bits &= ~(FloatProp::signMask);
-    UIntType sign = UIntType(signVal) << (FloatProp::bitWidth - 1);
+  void set_sign(bool signVal) {
+    bits &= ~(FloatProp::SIGN_MASK);
+    UIntType sign = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
     bits |= sign;
   }
 
-  bool getSign() const {
-    return ((bits & FloatProp::signMask) >> (FloatProp::bitWidth - 1));
+  bool get_sign() const {
+    return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
   }
   T val;
 
   static_assert(sizeof(T) == sizeof(UIntType),
                 "Data type and integral representation have different sizes.");
 
-  static constexpr int exponentBias = (1 << (ExponentWidth<T>::value - 1)) - 1;
-  static constexpr int maxExponent = (1 << ExponentWidth<T>::value) - 1;
+  static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
+  static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
 
-  static constexpr UIntType minSubnormal = UIntType(1);
-  static constexpr UIntType maxSubnormal =
-      (UIntType(1) << MantissaWidth<T>::value) - 1;
-  static constexpr UIntType minNormal =
-      (UIntType(1) << MantissaWidth<T>::value);
-  static constexpr UIntType maxNormal =
-      ((UIntType(maxExponent) - 1) << MantissaWidth<T>::value) | maxSubnormal;
+  static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
+  static constexpr UIntType MAX_SUBNORMAL =
+      (UIntType(1) << MantissaWidth<T>::VALUE) - 1;
+  static constexpr UIntType MIN_NORMAL =
+      (UIntType(1) << MantissaWidth<T>::VALUE);
+  static constexpr UIntType MAX_NORMAL =
+      ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
 
   // We don't want accidental type promotions/conversions so we require exact
   // type match.
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<T, XType>::Value, int> = 0>
   explicit FPBits(XType x) : val(x) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
   FPBits() : bits(0) {}
 
   explicit operator T() { return val; }
 
   UIntType uintval() const { return bits; }
 
-  int getExponent() const { return int(getUnbiasedExponent()) - exponentBias; }
+  int get_exponent() const {
+    return int(get_unbiased_exponent()) - EXPONENT_BIAS;
+  }
 
-  bool isZero() const {
-    return getMantissa() == 0 && getUnbiasedExponent() == 0;
+  bool is_zero() const {
+    return get_mantissa() == 0 && get_unbiased_exponent() == 0;
   }
 
-  bool isInf() const {
-    return getMantissa() == 0 && getUnbiasedExponent() == maxExponent;
+  bool is_inf() const {
+    return get_mantissa() == 0 && get_unbiased_exponent() == MAX_EXPONENT;
   }
 
-  bool isNaN() const {
-    return getUnbiasedExponent() == maxExponent && getMantissa() != 0;
+  bool is_nan() const {
+    return get_unbiased_exponent() == MAX_EXPONENT && get_mantissa() != 0;
   }
 
-  bool isInfOrNaN() const { return getUnbiasedExponent() == maxExponent; }
+  bool is_inf_or_nan() const { return get_unbiased_exponent() == MAX_EXPONENT; }
 
   static FPBits<T> zero() { return FPBits(); }
 
-  static FPBits<T> negZero() {
+  static FPBits<T> neg_zero() {
     return FPBits(UIntType(1) << (sizeof(UIntType) * 8 - 1));
   }
 
   static FPBits<T> inf() {
     FPBits<T> bits;
-    bits.setUnbiasedExponent(maxExponent);
+    bits.set_unbiased_exponent(MAX_EXPONENT);
     return bits;
   }
 
-  static FPBits<T> negInf() {
+  static FPBits<T> neg_inf() {
     FPBits<T> bits = inf();
-    bits.setSign(1);
+    bits.set_sign(1);
     return bits;
   }
 
-  static T buildNaN(UIntType v) {
+  static T build_nan(UIntType v) {
     FPBits<T> bits = inf();
-    bits.setMantissa(v);
+    bits.set_mantissa(v);
     return T(bits);
   }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/LongDoubleBits.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/__support/FPUtil/FloatProperties.h

 
 template <typename T> struct FloatProperties {};
 
 template <> struct FloatProperties<float> {
   typedef uint32_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(float),
                 "Unexpected size of 'float' type.");
 
-  static constexpr uint32_t bitWidth = sizeof(BitsType) << 3;
+  static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) << 3;
 
-  static constexpr uint32_t mantissaWidth = 23;
-  static constexpr uint32_t exponentWidth = 8;
-  static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
-  static constexpr BitsType signMask = BitsType(1)
-                                       << (exponentWidth + mantissaWidth);
-  static constexpr BitsType exponentMask = ~(signMask | mantissaMask);
-  static constexpr uint32_t exponentBias = 127;
+  static constexpr uint32_t MANTISSA_WIDTH = 23;
+  static constexpr uint32_t EXPONENT_WIDTH = 8;
+  static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
+  static constexpr BitsType SIGN_MASK = BitsType(1)
+                                        << (EXPONENT_WIDTH + MANTISSA_WIDTH);
+  static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
+  static constexpr uint32_t EXPONENT_BIAS = 127;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
-  static constexpr BitsType quietNaNMask = 0x00400000U;
+  static constexpr BitsType QUIET_NAN_MASK = 0x00400000U;
 };
 
 template <> struct FloatProperties<double> {
   typedef uint64_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(double),
                 "Unexpected size of 'double' type.");
 
-  static constexpr uint32_t bitWidth = sizeof(BitsType) << 3;
+  static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) << 3;
 
-  static constexpr uint32_t mantissaWidth = 52;
-  static constexpr uint32_t exponentWidth = 11;
-  static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
-  static constexpr BitsType signMask = BitsType(1)
-                                       << (exponentWidth + mantissaWidth);
-  static constexpr BitsType exponentMask = ~(signMask | mantissaMask);
-  static constexpr uint32_t exponentBias = 1023;
+  static constexpr uint32_t MANTISSA_WIDTH = 52;
+  static constexpr uint32_t EXPONENT_WIDTH = 11;
+  static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
+  static constexpr BitsType SIGN_MASK = BitsType(1)
+                                        << (EXPONENT_WIDTH + MANTISSA_WIDTH);
+  static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
+  static constexpr uint32_t EXPONENT_BIAS = 1023;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
-  static constexpr BitsType quietNaNMask = 0x0008000000000000ULL;
+  static constexpr BitsType QUIET_NAN_MASK = 0x0008000000000000ULL;
 };
 
 #if defined(LONG_DOUBLE_IS_DOUBLE)
 // Properties for numbers represented in 64 bits long double on Windows
 // platform.
 template <> struct FloatProperties<long double> {
   typedef uint64_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(double),
                 "Unexpected size of 'double' type.");
 
-  static constexpr uint32_t bitWidth = FloatProperties<double>::bitWidth;
+  static constexpr uint32_t BIT_WIDTH = FloatProperties<double>::BIT_WIDTH;
 
-  static constexpr uint32_t mantissaWidth =
-      FloatProperties<double>::mantissaWidth;
-  static constexpr uint32_t exponentWidth =
-      FloatProperties<double>::exponentWidth;
-  static constexpr BitsType mantissaMask =
-      FloatProperties<double>::mantissaMask;
-  static constexpr BitsType signMask = FloatProperties<double>::signMask;
-  static constexpr BitsType exponentMask =
-      FloatProperties<double>::exponentMask;
-  static constexpr uint32_t exponentBias =
-      FloatProperties<double>::exponentBias;
+  static constexpr uint32_t MANTISSA_WIDTH =
+      FloatProperties<double>::MANTISSA_WIDTH;
+  static constexpr uint32_t EXPONENT_WIDTH =
+      FloatProperties<double>::EXPONENT_WIDTH;
+  static constexpr BitsType MANTISSA_MASK =
+      FloatProperties<double>::MANTISSA_MASK;
+  static constexpr BitsType SIGN_MASK = FloatProperties<double>::SIGN_MASK;
+  static constexpr BitsType EXPONENT_MASK =
+      FloatProperties<double>::EXPONENT_MASK;
+  static constexpr uint32_t EXPONENT_BIAS =
+      FloatProperties<double>::EXPONENT_BIAS;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
-  static constexpr BitsType quietNaNMask =
-      FloatProperties<double>::quietNaNMask;
+  static constexpr BitsType QUIET_NAN_MASK =
+      FloatProperties<double>::QUIET_NAN_MASK;
 };
 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 // Properties for numbers represented in 80 bits long double on non-Windows x86
 // platforms.
 template <> struct FloatProperties<long double> {
   typedef __uint128_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
-  static constexpr uint32_t bitWidth = (sizeof(BitsType) << 3) - 48;
+  static constexpr uint32_t BIT_WIDTH = (sizeof(BitsType) << 3) - 48;
 
-  static constexpr uint32_t mantissaWidth = 63;
-  static constexpr uint32_t exponentWidth = 15;
-  static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
-  static constexpr BitsType signMask = BitsType(1)
-                                       << (exponentWidth + mantissaWidth + 1);
-  static constexpr BitsType exponentMask = ((BitsType(1) << exponentWidth) - 1)
-                                           << (mantissaWidth + 1);
-  static constexpr uint32_t exponentBias = 16383;
+  static constexpr uint32_t MANTISSA_WIDTH = 63;
+  static constexpr uint32_t EXPONENT_WIDTH = 15;
+  static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
+  static constexpr BitsType SIGN_MASK =
+      BitsType(1) << (EXPONENT_WIDTH + MANTISSA_WIDTH + 1);
+  static constexpr BitsType EXPONENT_MASK =
+      ((BitsType(1) << EXPONENT_WIDTH) - 1) << (MANTISSA_WIDTH + 1);
+  static constexpr uint32_t EXPONENT_BIAS = 16383;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
-  static constexpr BitsType quietNaNMask = BitsType(1) << (mantissaWidth - 1);
+  static constexpr BitsType QUIET_NAN_MASK = BitsType(1)
+                                             << (MANTISSA_WIDTH - 1);
 };
 #else
 // Properties for numbers represented in 128 bits long double on non x86
 // platform.
 template <> struct FloatProperties<long double> {
   typedef __uint128_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(long double),
                 "Unexpected size of 'long double' type.");
 
-  static constexpr uint32_t bitWidth = sizeof(BitsType) << 3;
+  static constexpr uint32_t BIT_WIDTH = sizeof(BitsType) << 3;
 
-  static constexpr uint32_t mantissaWidth = 112;
-  static constexpr uint32_t exponentWidth = 15;
-  static constexpr BitsType mantissaMask = (BitsType(1) << mantissaWidth) - 1;
-  static constexpr BitsType signMask = BitsType(1)
-                                       << (exponentWidth + mantissaWidth);
-  static constexpr BitsType exponentMask = ~(signMask | mantissaMask);
-  static constexpr uint32_t exponentBias = 16383;
+  static constexpr uint32_t MANTISSA_WIDTH = 112;
+  static constexpr uint32_t EXPONENT_WIDTH = 15;
+  static constexpr BitsType MANTISSA_MASK = (BitsType(1) << MANTISSA_WIDTH) - 1;
+  static constexpr BitsType SIGN_MASK = BitsType(1)
+                                        << (EXPONENT_WIDTH + MANTISSA_WIDTH);
+  static constexpr BitsType EXPONENT_MASK = ~(SIGN_MASK | MANTISSA_MASK);
+  static constexpr uint32_t EXPONENT_BIAS = 16383;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
-  static constexpr BitsType quietNaNMask = BitsType(1) << (mantissaWidth - 1);
+  static constexpr BitsType QUIET_NAN_MASK = BitsType(1)
+                                             << (MANTISSA_WIDTH - 1);
 };
 #endif
 
 // Define the float type corresponding to the BitsType.
 template <typename BitsType> struct FloatType;
 
 template <> struct FloatType<uint32_t> {
   static_assert(sizeof(uint32_t) == sizeof(float),

libc/src/__support/FPUtil/Hypot.h

 #include "FPBits.h"
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
-template <typename T> static inline T findLeadingOne(T mant, int &shift_length);
+template <typename T>
+static inline T find_leading_one(T mant, int &shift_length);
 
 template <>
-inline uint32_t findLeadingOne<uint32_t>(uint32_t mant, int &shift_length) {
+inline uint32_t find_leading_one<uint32_t>(uint32_t mant, int &shift_length) {
   shift_length = 0;
-  constexpr int nsteps = 5;
-  constexpr uint32_t bounds[nsteps] = {1 << 16, 1 << 8, 1 << 4, 1 << 2, 1 << 1};
-  constexpr int shifts[nsteps] = {16, 8, 4, 2, 1};
-  for (int i = 0; i < nsteps; ++i) {
-    if (mant >= bounds[i]) {
-      shift_length += shifts[i];
-      mant >>= shifts[i];
+  constexpr int NSTEPS = 5;
+  constexpr uint32_t BOUNDS[NSTEPS] = {1 << 16, 1 << 8, 1 << 4, 1 << 2, 1 << 1};
+  constexpr int SHIFTS[NSTEPS] = {16, 8, 4, 2, 1};
+  for (int i = 0; i < NSTEPS; ++i) {
+    if (mant >= BOUNDS[i]) {
+      shift_length += SHIFTS[i];
+      mant >>= SHIFTS[i];
     }
   }
   return 1U << shift_length;
 }
 
 template <>
-inline uint64_t findLeadingOne<uint64_t>(uint64_t mant, int &shift_length) {
+inline uint64_t find_leading_one<uint64_t>(uint64_t mant, int &shift_length) {
   shift_length = 0;
-  constexpr int nsteps = 6;
-  constexpr uint64_t bounds[nsteps] = {1ULL << 32, 1ULL << 16, 1ULL << 8,
+  constexpr int NSTEPS = 6;
+  constexpr uint64_t BOUNDS[NSTEPS] = {1ULL << 32, 1ULL << 16, 1ULL << 8,
                                        1ULL << 4,  1ULL << 2,  1ULL << 1};
-  constexpr int shifts[nsteps] = {32, 16, 8, 4, 2, 1};
-  for (int i = 0; i < nsteps; ++i) {
-    if (mant >= bounds[i]) {
-      shift_length += shifts[i];
-      mant >>= shifts[i];
+  constexpr int SHIFTS[NSTEPS] = {32, 16, 8, 4, 2, 1};
+  for (int i = 0; i < NSTEPS; ++i) {
+    if (mant >= BOUNDS[i]) {
+      shift_length += SHIFTS[i];
+      mant >>= SHIFTS[i];
     }
   }
   return 1ULL << shift_length;
 }
 
 } // namespace internal
 
 template <typename T> struct DoubleLength;
template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T hypot(T x, T y) {
   using FPBits_t = FPBits<T>;
   using UIntType = typename FPBits<T>::UIntType;
   using DUIntType = typename DoubleLength<UIntType>::Type;
 
   FPBits_t x_bits(x), y_bits(y);
 
-  if (x_bits.isInf() || y_bits.isInf()) {
+  if (x_bits.is_inf() || y_bits.is_inf()) {
     return T(FPBits_t::inf());
   }
-  if (x_bits.isNaN()) {
+  if (x_bits.is_nan()) {
     return x;
   }
-  if (y_bits.isNaN()) {
+  if (y_bits.is_nan()) {
     return y;
   }
 
   uint16_t a_exp, b_exp, out_exp;
   UIntType a_mant, b_mant;
   DUIntType a_mant_sq, b_mant_sq;
   bool sticky_bits;
 
-  if ((x_bits.getUnbiasedExponent() >=
-       y_bits.getUnbiasedExponent() + MantissaWidth<T>::value + 2) ||
+  if ((x_bits.get_unbiased_exponent() >=
+       y_bits.get_unbiased_exponent() + MantissaWidth<T>::VALUE + 2) ||
       (y == 0)) {
     return abs(x);
-  } else if ((y_bits.getUnbiasedExponent() >=
-              x_bits.getUnbiasedExponent() + MantissaWidth<T>::value + 2) ||
+  } else if ((y_bits.get_unbiased_exponent() >=
+              x_bits.get_unbiased_exponent() + MantissaWidth<T>::VALUE + 2) ||
              (x == 0)) {
-    y_bits.setSign(0);
+    y_bits.set_sign(0);
     return abs(y);
   }
 
   if (abs(x) >= abs(y)) {
-    a_exp = x_bits.getUnbiasedExponent();
-    a_mant = x_bits.getMantissa();
-    b_exp = y_bits.getUnbiasedExponent();
-    b_mant = y_bits.getMantissa();
+    a_exp = x_bits.get_unbiased_exponent();
+    a_mant = x_bits.get_mantissa();
+    b_exp = y_bits.get_unbiased_exponent();
+    b_mant = y_bits.get_mantissa();
   } else {
-    a_exp = y_bits.getUnbiasedExponent();
-    a_mant = y_bits.getMantissa();
-    b_exp = x_bits.getUnbiasedExponent();
-    b_mant = x_bits.getMantissa();
+    a_exp = y_bits.get_unbiased_exponent();
+    a_mant = y_bits.get_mantissa();
+    b_exp = x_bits.get_unbiased_exponent();
+    b_mant = x_bits.get_mantissa();
   }
 
   out_exp = a_exp;
 
   // Add an extra bit to simplify the final rounding bit computation.
-  constexpr UIntType one = UIntType(1) << (MantissaWidth<T>::value + 1);
+  constexpr UIntType ONE = UIntType(1) << (MantissaWidth<T>::VALUE + 1);
 
   a_mant <<= 1;
   b_mant <<= 1;
 
   UIntType leading_one;
   int y_mant_width;
   if (a_exp != 0) {
-    leading_one = one;
-    a_mant |= one;
-    y_mant_width = MantissaWidth<T>::value + 1;
+    leading_one = ONE;
+    a_mant |= ONE;
+    y_mant_width = MantissaWidth<T>::VALUE + 1;
   } else {
-    leading_one = internal::findLeadingOne(a_mant, y_mant_width);
+    leading_one = internal::find_leading_one(a_mant, y_mant_width);
     a_exp = 1;
   }
 
   if (b_exp != 0) {
-    b_mant |= one;
+    b_mant |= ONE;
   } else {
     b_exp = 1;
   }
 
   a_mant_sq = static_cast<DUIntType>(a_mant) * a_mant;
   b_mant_sq = static_cast<DUIntType>(b_mant) * b_mant;
 
   // At this point, a_exp >= b_exp > a_exp - 25, so in order to line up aSqMant
   // and bSqMant, we need to shift bSqMant to the right by (a_exp - b_exp) bits.
   // But before that, remember to store the losing bits to sticky.
   // The shift length is for a^2 and b^2, so it's double of the exponent
   // difference between a and b.
   uint16_t shift_length = 2 * (a_exp - b_exp);
   sticky_bits =
       ((b_mant_sq & ((DUIntType(1) << shift_length) - DUIntType(1))) !=
        DUIntType(0));
   b_mant_sq >>= shift_length;
 
   DUIntType sum = a_mant_sq + b_mant_sq;
   if (sum >= (DUIntType(1) << (2 * y_mant_width + 2))) {
     // a^2 + b^2 >= 4* leading_one^2, so we will need an extra bit to the left.
-    if (leading_one == one) {
+    if (leading_one == ONE) {
       // For normal result, we discard the last 2 bits of the sum and increase
       // the exponent.
       sticky_bits = sticky_bits || ((sum & 0x3U) != 0);
       sum >>= 2;
       ++out_exp;
-      if (out_exp >= FPBits_t::maxExponent) {
+      if (out_exp >= FPBits_t::MAX_EXPONENT) {
         return T(FPBits_t::inf());
       }
     } else {
       // For denormal result, we simply move the leading bit of the result to
       // the left by 1.
       leading_one <<= 1;
       ++y_mant_width;
     }
   }
 
-  UIntType Y = leading_one;
-  UIntType R = static_cast<UIntType>(sum >> y_mant_width) - leading_one;
-  UIntType tailBits = static_cast<UIntType>(sum) & (leading_one - 1);
+  UIntType y_new = leading_one;
+  UIntType r = static_cast<UIntType>(sum >> y_mant_width) - leading_one;
+  UIntType tail_bits = static_cast<UIntType>(sum) & (leading_one - 1);
 
   for (UIntType current_bit = leading_one >> 1; current_bit;
        current_bit >>= 1) {
-    R = (R << 1) + ((tailBits & current_bit) ? 1 : 0);
-    UIntType tmp = (Y << 1) + current_bit; // 2*y(n - 1) + 2^(-n)
-    if (R >= tmp) {
-      R -= tmp;
-      Y += current_bit;
+    r = (r << 1) + ((tail_bits & current_bit) ? 1 : 0);
+    UIntType tmp = (y_new << 1) + current_bit; // 2*y_new(n - 1) + 2^(-n)
+    if (r >= tmp) {
+      r -= tmp;
+      y_new += current_bit;
     }
   }
 
-  bool round_bit = Y & UIntType(1);
-  bool lsb = Y & UIntType(2);
+  bool round_bit = y_new & UIntType(1);
+  bool lsb = y_new & UIntType(2);
 
-  if (Y >= one) {
-    Y -= one;
+  if (y_new >= ONE) {
+    y_new -= ONE;
 
     if (out_exp == 0) {
       out_exp = 1;
     }
   }
 
-  Y >>= 1;
+  y_new >>= 1;
 
   // Round to the nearest, tie to even.
-  if (round_bit && (lsb || sticky_bits || (R != 0))) {
-    ++Y;
+  if (round_bit && (lsb || sticky_bits || (r != 0))) {
+    ++y_new;
   }
 
-  if (Y >= (one >> 1)) {
-    Y -= one >> 1;
+  if (y_new >= (ONE >> 1)) {
+    y_new -= ONE >> 1;
     ++out_exp;
-    if (out_exp >= FPBits_t::maxExponent) {
+    if (out_exp >= FPBits_t::MAX_EXPONENT) {
       return T(FPBits_t::inf());
     }
   }
 
-  Y |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::value;
-  return *reinterpret_cast<T *>(&Y);
+  y_new |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::VALUE;
+  return *reinterpret_cast<T *>(&y_new);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H

libc/src/__support/FPUtil/ManipulationFunctions.h

 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T frexp(T x, int &exp) {
   FPBits<T> bits(x);
-  if (bits.isInfOrNaN())
+  if (bits.is_inf_or_nan())
     return x;
-  if (bits.isZero()) {
+  if (bits.is_zero()) {
     exp = 0;
     return x;
   }
 
   NormalFloat<T> normal(bits);
   exp = normal.exponent + 1;
   normal.exponent = -1;
   return normal;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T modf(T x, T &iptr) {
   FPBits<T> bits(x);
-  if (bits.isZero() || bits.isNaN()) {
+  if (bits.is_zero() || bits.is_nan()) {
     iptr = x;
     return x;
-  } else if (bits.isInf()) {
+  } else if (bits.is_inf()) {
     iptr = x;
-    return bits.getSign() ? T(FPBits<T>::negZero()) : T(FPBits<T>::zero());
+    return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
   } else {
     iptr = trunc(x);
     if (x == iptr) {
       // If x is already an integer value, then return zero with the right
       // sign.
-      return bits.getSign() ? T(FPBits<T>::negZero()) : T(FPBits<T>::zero());
+      return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
     } else {
       return x - iptr;
     }
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T copysign(T x, T y) {
   FPBits<T> xbits(x);
-  xbits.setSign(FPBits<T>(y).getSign());
+  xbits.set_sign(FPBits<T>(y).get_sign());
   return T(xbits);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline int ilogb(T x) {
   // TODO: Raise appropriate floating point exceptions and set errno to the
   // an appropriate error value wherever relevant.
   FPBits<T> bits(x);
-  if (bits.isZero()) {
+  if (bits.is_zero()) {
     return FP_ILOGB0;
-  } else if (bits.isNaN()) {
+  } else if (bits.is_nan()) {
     return FP_ILOGBNAN;
-  } else if (bits.isInf()) {
+  } else if (bits.is_inf()) {
     return INT_MAX;
   }
 
   NormalFloat<T> normal(bits);
   // The C standard does not specify the return value when an exponent is
   // out of int range. However, XSI conformance required that INT_MAX or
   // INT_MIN are returned.
   // NOTE: It is highly unlikely that exponent will be out of int range as
   // the exponent is only 15 bits wide even for the 128-bit floating point
   // format.
   if (normal.exponent > INT_MAX)
     return INT_MAX;
   else if (normal.exponent < INT_MIN)
     return INT_MIN;
   else
     return normal.exponent;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T logb(T x) {
   FPBits<T> bits(x);
-  if (bits.isZero()) {
+  if (bits.is_zero()) {
     // TODO(Floating point exception): Raise div-by-zero exception.
     // TODO(errno): POSIX requires setting errno to ERANGE.
-    return T(FPBits<T>::negInf());
-  } else if (bits.isNaN()) {
+    return T(FPBits<T>::neg_inf());
+  } else if (bits.is_nan()) {
     return x;
-  } else if (bits.isInf()) {
+  } else if (bits.is_inf()) {
     // Return positive infinity.
     return T(FPBits<T>::inf());
   }
 
   NormalFloat<T> normal(bits);
   return normal.exponent;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T ldexp(T x, int exp) {
   FPBits<T> bits(x);
-  if (bits.isZero() || bits.isInfOrNaN() || exp == 0)
+  if (bits.is_zero() || bits.is_inf_or_nan() || exp == 0)
     return x;
 
   // NormalFloat uses int32_t to store the true exponent value. We should ensure
   // that adding |exp| to it does not lead to integer rollover. But, if |exp|
   // value is larger the exponent range for type T, then we can return infinity
   // early. Because the result of the ldexp operation can be a subnormal number,
   // we need to accommodate the (mantissaWidht + 1) worth of shift in
   // calculating the limit.
-  int expLimit = FPBits<T>::maxExponent + MantissaWidth<T>::value + 1;
-  if (exp > expLimit)
-    return bits.getSign() ? T(FPBits<T>::negInf()) : T(FPBits<T>::inf());
+  int exp_limit = FPBits<T>::MAX_EXPONENT + MantissaWidth<T>::VALUE + 1;
+  if (exp > exp_limit)
+    return bits.get_sign() ? T(FPBits<T>::neg_inf()) : T(FPBits<T>::inf());
 
   // Similarly on the negative side we return zero early if |exp| is too small.
-  if (exp < -expLimit)
-    return bits.getSign() ? T(FPBits<T>::negZero()) : T(FPBits<T>::zero());
+  if (exp < -exp_limit)
+    return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
 
   // For all other values, NormalFloat to T conversion handles it the right way.
   NormalFloat<T> normal(bits);
   normal.exponent += exp;
   return normal;
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T nextafter(T from, T to) {
-  FPBits<T> fromBits(from);
-  if (fromBits.isNaN())
+  FPBits<T> from_bits(from);
+  if (from_bits.is_nan())
     return from;
 
-  FPBits<T> toBits(to);
-  if (toBits.isNaN())
+  FPBits<T> to_bits(to);
+  if (to_bits.is_nan())
     return to;
 
   if (from == to)
     return to;
 
   using UIntType = typename FPBits<T>::UIntType;
-  UIntType intVal = fromBits.uintval();
-  UIntType signMask = (UIntType(1) << (sizeof(T) * 8 - 1));
+  UIntType int_val = from_bits.uintval();
+  UIntType sign_mask = (UIntType(1) << (sizeof(T) * 8 - 1));
   if (from != T(0.0)) {
     if ((from < to) == (from > T(0.0))) {
-      ++intVal;
+      ++int_val;
     } else {
-      --intVal;
+      --int_val;
     }
   } else {
-    intVal = (toBits.uintval() & signMask) + UIntType(1);
+    int_val = (to_bits.uintval() & sign_mask) + UIntType(1);
   }
 
-  return *reinterpret_cast<T *>(&intVal);
+  return *reinterpret_cast<T *>(&int_val);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/NextAfterLongDouble.h"
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/src/__support/FPUtil/NearestIntegerOperations.h

template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T trunc(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity or NaN, return it.
   // If it is zero also we should return it as is, but the logic
   // later in this function takes care of it. But not doing a zero
   // check, we improve the run time of non-zero values.
-  if (bits.isInfOrNaN())
+  if (bits.is_inf_or_nan())
     return x;
 
-  int exponent = bits.getExponent();
+  int exponent = bits.get_exponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::VALUE))
     return x;
 
   // If the exponent is such that abs(x) is less than 1, then return 0.
   if (exponent <= -1) {
-    if (bits.getSign())
+    if (bits.get_sign())
       return T(-0.0);
     else
       return T(0.0);
   }
 
-  int trimSize = MantissaWidth<T>::value - exponent;
-  bits.setMantissa((bits.getMantissa() >> trimSize) << trimSize);
+  int trim_size = MantissaWidth<T>::VALUE - exponent;
+  bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
   return T(bits);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T ceil(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
-  if (bits.isInfOrNaN() || bits.isZero())
+  if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
-  bool isNeg = bits.getSign();
-  int exponent = bits.getExponent();
+  bool is_neg = bits.get_sign();
+  int exponent = bits.get_exponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::VALUE))
     return x;
 
   if (exponent <= -1) {
-    if (isNeg)
+    if (is_neg)
       return T(-0.0);
     else
       return T(1.0);
   }
 
-  uint32_t trimSize = MantissaWidth<T>::value - exponent;
-  bits.setMantissa((bits.getMantissa() >> trimSize) << trimSize);
-  T truncValue = T(bits);
+  uint32_t trim_size = MantissaWidth<T>::VALUE - exponent;
+  bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
+  T trunc_value = T(bits);
 
   // If x is already an integer, return it.
-  if (truncValue == x)
+  if (trunc_value == x)
     return x;
 
   // If x is negative, the ceil operation is equivalent to the trunc operation.
-  if (isNeg)
-    return truncValue;
+  if (is_neg)
+    return trunc_value;
 
-  return truncValue + T(1.0);
+  return trunc_value + T(1.0);
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T floor(T x) {
   FPBits<T> bits(x);
-  if (bits.getSign()) {
+  if (bits.get_sign()) {
     return -ceil(-x);
   } else {
     return trunc(x);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T round(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
-  if (bits.isInfOrNaN() || bits.isZero())
+  if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
-  bool isNeg = bits.getSign();
-  int exponent = bits.getExponent();
+  bool is_neg = bits.get_sign();
+  int exponent = bits.get_exponent();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::VALUE))
     return x;
 
   if (exponent == -1) {
     // Absolute value of x is greater than equal to 0.5 but less than 1.
-    if (isNeg)
+    if (is_neg)
       return T(-1.0);
     else
       return T(1.0);
   }
 
   if (exponent <= -2) {
     // Absolute value of x is less than 0.5.
-    if (isNeg)
+    if (is_neg)
       return T(-0.0);
     else
       return T(0.0);
   }
 
-  uint32_t trimSize = MantissaWidth<T>::value - exponent;
-  bool halfBitSet = bits.getMantissa() & (UIntType(1) << (trimSize - 1));
-  bits.setMantissa((bits.getMantissa() >> trimSize) << trimSize);
-  T truncValue = T(bits);
+  uint32_t trim_size = MantissaWidth<T>::VALUE - exponent;
+  bool half_bit_set = bits.get_mantissa() & (UIntType(1) << (trim_size - 1));
+  bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
+  T trunc_value = T(bits);
 
   // If x is already an integer, return it.
-  if (truncValue == x)
+  if (trunc_value == x)
     return x;
 
-  if (!halfBitSet) {
+  if (!half_bit_set) {
     // Franctional part is less than 0.5 so round value is the
     // same as the trunc value.
-    return truncValue;
+    return trunc_value;
   } else {
-    return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
+    return is_neg ? trunc_value - T(1.0) : trunc_value + T(1.0);
   }
 }
 
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
-static inline T roundUsingCurrentRoundingMode(T x) {
+static inline T round_using_current_rounding_mode(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
-  if (bits.isInfOrNaN() || bits.isZero())
+  if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
-  bool isNeg = bits.getSign();
-  int exponent = bits.getExponent();
-  int roundingMode = getRound();
+  bool is_neg = bits.get_sign();
+  int exponent = bits.get_exponent();
+  int rounding_mode = get_round();
 
   // If the exponent is greater than the most negative mantissa
   // exponent, then x is already an integer.
-  if (exponent >= static_cast<int>(MantissaWidth<T>::value))
+  if (exponent >= static_cast<int>(MantissaWidth<T>::VALUE))
     return x;
 
   if (exponent <= -1) {
-    switch (roundingMode) {
+    switch (rounding_mode) {
     case FE_DOWNWARD:
-      return isNeg ? T(-1.0) : T(0.0);
+      return is_neg ? T(-1.0) : T(0.0);
     case FE_UPWARD:
-      return isNeg ? T(-0.0) : T(1.0);
+      return is_neg ? T(-0.0) : T(1.0);
     case FE_TOWARDZERO:
-      return isNeg ? T(-0.0) : T(0.0);
+      return is_neg ? T(-0.0) : T(0.0);
     case FE_TONEAREST:
-      if (exponent <= -2 || bits.getMantissa() == 0)
-        return isNeg ? T(-0.0) : T(0.0); // abs(x) <= 0.5
+      if (exponent <= -2 || bits.get_mantissa() == 0)
+        return is_neg ? T(-0.0) : T(0.0); // abs(x) <= 0.5
       else
-        return isNeg ? T(-1.0) : T(1.0); // abs(x) > 0.5
+        return is_neg ? T(-1.0) : T(1.0); // abs(x) > 0.5
     default:
       __builtin_unreachable();
     }
   }
 
-  uint32_t trimSize = MantissaWidth<T>::value - exponent;
-  FPBits<T> newBits = bits;
-  newBits.setMantissa((bits.getMantissa() >> trimSize) << trimSize);
-  T truncValue = T(newBits);
+  uint32_t trim_size = MantissaWidth<T>::VALUE - exponent;
+  FPBits<T> new_bits = bits;
+  new_bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
+  T trunc_value = T(new_bits);
 
   // If x is already an integer, return it.
-  if (truncValue == x)
+  if (trunc_value == x)
     return x;
 
-  UIntType trimValue = bits.getMantissa() & ((UIntType(1) << trimSize) - 1);
-  UIntType halfValue = (UIntType(1) << (trimSize - 1));
+  UIntType trim_value = bits.get_mantissa() & ((UIntType(1) << trim_size) - 1);
+  UIntType half_value = (UIntType(1) << (trim_size - 1));
   // If exponent is 0, trimSize will be equal to the mantissa width, and
   // truncIsOdd` will not be correct. So, we handle it as a special case
   // below.
-  UIntType truncIsOdd = newBits.getMantissa() & (UIntType(1) << trimSize);
+  UIntType trunc_is_odd = new_bits.get_mantissa() & (UIntType(1) << trim_size);
 
-  switch (roundingMode) {
+  switch (rounding_mode) {
   case FE_DOWNWARD:
-    return isNeg ? truncValue - T(1.0) : truncValue;
+    return is_neg ? trunc_value - T(1.0) : trunc_value;
   case FE_UPWARD:
-    return isNeg ? truncValue : truncValue + T(1.0);
+    return is_neg ? trunc_value : trunc_value + T(1.0);
   case FE_TOWARDZERO:
-    return truncValue;
+    return trunc_value;
   case FE_TONEAREST:
-    if (trimValue > halfValue) {
-      return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
-    } else if (trimValue == halfValue) {
+    if (trim_value > half_value) {
+      return is_neg ? trunc_value - T(1.0) : trunc_value + T(1.0);
+    } else if (trim_value == half_value) {
       if (exponent == 0)
-        return isNeg ? T(-2.0) : T(2.0);
-      if (truncIsOdd)
-        return isNeg ? truncValue - T(1.0) : truncValue + T(1.0);
+        return is_neg ? T(-2.0) : T(2.0);
+      if (trunc_is_odd)
+        return is_neg ? trunc_value - T(1.0) : trunc_value + T(1.0);
       else
-        return truncValue;
+        return trunc_value;
     } else {
-      return truncValue;
+      return trunc_value;
     }
   default:
     __builtin_unreachable();
   }
 }
 
 namespace internal {
 
 template <typename F, typename I,
           cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
                                 cpp::IsIntegral<I>::Value,
                             int> = 0>
-static inline I roundedFloatToSignedInteger(F x) {
-  constexpr I IntegerMin = (I(1) << (sizeof(I) * 8 - 1));
-  constexpr I IntegerMax = -(IntegerMin + 1);
+static inline I rounded_float_to_signed_integer(F x) {
+  constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1));
+  constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
   FPBits<F> bits(x);
-  auto setDomainErrorAndRaiseInvalid = []() {
+  auto set_domain_error_and_raise_invalid = []() {
 #if math_errhandling & MATH_ERRNO
     errno = EDOM;
 #endif
 #if math_errhandling & MATH_ERREXCEPT
-    raiseExcept(FE_INVALID);
+    raise_except(FE_INVALID);
 #endif
   };
 
-  if (bits.isInfOrNaN()) {
-    setDomainErrorAndRaiseInvalid();
-    return bits.getSign() ? IntegerMin : IntegerMax;
+  if (bits.is_inf_or_nan()) {
+    set_domain_error_and_raise_invalid();
+    return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX;
   }
 
-  int exponent = bits.getExponent();
-  constexpr int exponentLimit = sizeof(I) * 8 - 1;
-  if (exponent > exponentLimit) {
-    setDomainErrorAndRaiseInvalid();
-    return bits.getSign() ? IntegerMin : IntegerMax;
-  } else if (exponent == exponentLimit) {
-    if (bits.getSign() == 0 || bits.getMantissa() != 0) {
-      setDomainErrorAndRaiseInvalid();
-      return bits.getSign() ? IntegerMin : IntegerMax;
+  int exponent = bits.get_exponent();
+  constexpr int EXPONENT_LIMIT = sizeof(I) * 8 - 1;
+  if (exponent > EXPONENT_LIMIT) {
+    set_domain_error_and_raise_invalid();
+    return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX;
+  } else if (exponent == EXPONENT_LIMIT) {
+    if (bits.get_sign() == 0 || bits.get_mantissa() != 0) {
+      set_domain_error_and_raise_invalid();
+      return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX;
     }
     // If the control reaches here, then it means that the rounded
     // value is the most negative number for the signed integer type I.
   }
 
   // For all other cases, if `x` can fit in the integer type `I`,
   // we just return `x`. Implicit conversion will convert the
   // floating point value to the exact integer value.
   return x;
 }
 
 } // namespace internal
 
 template <typename F, typename I,
           cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
                                 cpp::IsIntegral<I>::Value,
                             int> = 0>
-static inline I roundToSignedInteger(F x) {
-  return internal::roundedFloatToSignedInteger<F, I>(round(x));
+static inline I round_to_signed_integer(F x) {
+  return internal::rounded_float_to_signed_integer<F, I>(round(x));
 }
 
 template <typename F, typename I,
           cpp::EnableIfType<cpp::IsFloatingPointType<F>::Value &&
                                 cpp::IsIntegral<I>::Value,
                             int> = 0>
-static inline I roundToSignedIntegerUsingCurrentRoundingMode(F x) {
-  return internal::roundedFloatToSignedInteger<F, I>(
-      roundUsingCurrentRoundingMode(x));
+static inline I round_to_signed_integer_using_current_rounding_mode(F x) {
+  return internal::rounded_float_to_signed_integer<F, I>(
+      round_using_current_rounding_mode(x));
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H

libc/src/__support/FPUtil/NormalFloat.h

 //    (-1)*sign * 2^exponent * <mantissa>
 // where <mantissa> is of the form 1.<...>.
 template <typename T> struct NormalFloat {
   static_assert(
       cpp::IsFloatingPointType<T>::Value,
       "NormalFloat template parameter has to be a floating point type.");
 
   using UIntType = typename FPBits<T>::UIntType;
-  static constexpr UIntType one = (UIntType(1) << MantissaWidth<T>::value);
+  static constexpr UIntType ONE = (UIntType(1) << MantissaWidth<T>::VALUE);
 
   // Unbiased exponent value.
   int32_t exponent;
 
   UIntType mantissa;
   // We want |UIntType| to have atleast one bit more than the actual mantissa
   // bit width to accommodate the implicit 1 value.
-  static_assert(sizeof(UIntType) * 8 >= MantissaWidth<T>::value + 1,
+  static_assert(sizeof(UIntType) * 8 >= MantissaWidth<T>::VALUE + 1,
                 "Bad type for mantissa in NormalFloat.");
 
   bool sign;
 
   NormalFloat(int32_t e, UIntType m, bool s)
       : exponent(e), mantissa(m), sign(s) {
-    if (mantissa >= one)
+    if (mantissa >= ONE)
       return;
 
-    unsigned normalizationShift = evaluateNormalizationShift(mantissa);
-    mantissa = mantissa << normalizationShift;
-    exponent -= normalizationShift;
+    unsigned normalization_shift = evaluate_normalization_shift(mantissa);
+    mantissa = mantissa << normalization_shift;
+    exponent -= normalization_shift;
   }
 
-  explicit NormalFloat(T x) { initFromBits(FPBits<T>(x)); }
+  explicit NormalFloat(T x) { init_from_bits(FPBits<T>(x)); }
 
-  explicit NormalFloat(FPBits<T> bits) { initFromBits(bits); }
+  explicit NormalFloat(FPBits<T> bits) { init_from_bits(bits); }
 
   // Compares this normalized number with another normalized number.
   // Returns -1 is this number is less than |other|, 0 if this number is equal
   // to |other|, and 1 if this number is greater than |other|.
   int cmp(const NormalFloat<T> &other) const {
     if (sign != other.sign)
       return sign ? -1 : 1;
 
template <typename T> struct NormalFloat {
   //     new = this *  2^e
   NormalFloat<T> mul2(int e) const {
     NormalFloat<T> result = *this;
     result.exponent += e;
     return result;
   }
 
   operator T() const {
-    int biasedExponent = exponent + FPBits<T>::exponentBias;
+    int biased_exponent = exponent + FPBits<T>::EXPONENT_BIAS;
     // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
-    constexpr int maxExponentValue = (1 << ExponentWidth<T>::value) - 2;
-    if (biasedExponent > maxExponentValue) {
-      return sign ? T(FPBits<T>::negInf()) : T(FPBits<T>::inf());
+    constexpr int MAX_EXPONENT_VALUE = (1 << ExponentWidth<T>::VALUE) - 2;
+    if (biased_exponent > MAX_EXPONENT_VALUE) {
+      return sign ? T(FPBits<T>::neg_inf()) : T(FPBits<T>::inf());
     }
 
     FPBits<T> result(T(0.0));
-    result.setSign(sign);
+    result.set_sign(sign);
 
-    constexpr int subnormalExponent = -FPBits<T>::exponentBias + 1;
-    if (exponent < subnormalExponent) {
-      unsigned shift = subnormalExponent - exponent;
+    constexpr int SUBNORMAL_EXPONENT = -FPBits<T>::EXPONENT_BIAS + 1;
+    if (exponent < SUBNORMAL_EXPONENT) {
+      unsigned shift = SUBNORMAL_EXPONENT - exponent;
       // Since exponent > subnormalExponent, shift is strictly greater than
       // zero.
-      if (shift <= MantissaWidth<T>::value + 1) {
+      if (shift <= MantissaWidth<T>::VALUE + 1) {
         // Generate a subnormal number. Might lead to loss of precision.
         // We round to nearest and round halfway cases to even.
-        const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
-        const UIntType shiftOutValue = mantissa & shiftOutMask;
-        const UIntType halfwayValue = UIntType(1) << (shift - 1);
-        result.setUnbiasedExponent(0);
-        result.setMantissa(mantissa >> shift);
-        UIntType newMantissa = result.getMantissa();
-        if (shiftOutValue > halfwayValue) {
-          newMantissa += 1;
-        } else if (shiftOutValue == halfwayValue) {
+        const UIntType shift_out_mask = (UIntType(1) << shift) - 1;
+        const UIntType shift_out_value = mantissa & shift_out_mask;
+        const UIntType halfway_value = UIntType(1) << (shift - 1);
+        result.set_unbiased_exponent(0);
+        result.set_mantissa(mantissa >> shift);
+        UIntType new_mantissa = result.get_mantissa();
+        if (shift_out_value > halfway_value) {
+          new_mantissa += 1;
+        } else if (shift_out_value == halfway_value) {
           // Round to even.
-          if (result.getMantissa() & 0x1)
-            newMantissa += 1;
+          if (result.get_mantissa() & 0x1)
+            new_mantissa += 1;
         }
-        result.setMantissa(newMantissa);
+        result.set_mantissa(new_mantissa);
         // Adding 1 to mantissa can lead to overflow. This can only happen if
         // mantissa was all ones (0b111..11). For such a case, we will carry
         // the overflow into the exponent.
-        if (newMantissa == one)
-          result.setUnbiasedExponent(1);
+        if (new_mantissa == ONE)
+          result.set_unbiased_exponent(1);
         return T(result);
       } else {
         return T(result);
       }
     }
 
-    result.setUnbiasedExponent(exponent + FPBits<T>::exponentBias);
-    result.setMantissa(mantissa);
+    result.set_unbiased_exponent(exponent + FPBits<T>::EXPONENT_BIAS);
+    result.set_mantissa(mantissa);
     return T(result);
   }
 
 private:
-  void initFromBits(FPBits<T> bits) {
-    sign = bits.getSign();
+  void init_from_bits(FPBits<T> bits) {
+    sign = bits.get_sign();
 
-    if (bits.isInfOrNaN() || bits.isZero()) {
+    if (bits.is_inf_or_nan() || bits.is_zero()) {
       // Ignore special bit patterns. Implementations deal with them separately
       // anyway so this should not be a problem.
       exponent = 0;
       mantissa = 0;
       return;
     }
 
     // Normalize subnormal numbers.
-    if (bits.getUnbiasedExponent() == 0) {
-      unsigned shift = evaluateNormalizationShift(bits.getMantissa());
-      mantissa = UIntType(bits.getMantissa()) << shift;
-      exponent = 1 - FPBits<T>::exponentBias - shift;
+    if (bits.get_unbiased_exponent() == 0) {
+      unsigned shift = evaluate_normalization_shift(bits.get_mantissa());
+      mantissa = UIntType(bits.get_mantissa()) << shift;
+      exponent = 1 - FPBits<T>::EXPONENT_BIAS - shift;
     } else {
-      exponent = bits.getUnbiasedExponent() - FPBits<T>::exponentBias;
-      mantissa = one | bits.getMantissa();
+      exponent = bits.get_unbiased_exponent() - FPBits<T>::EXPONENT_BIAS;
+      mantissa = ONE | bits.get_mantissa();
     }
   }
 
-  unsigned evaluateNormalizationShift(UIntType m) {
+  unsigned evaluate_normalization_shift(UIntType m) {
     unsigned shift = 0;
-    for (; (one & m) == 0 && (shift < MantissaWidth<T>::value);
+    for (; (ONE & m) == 0 && (shift < MantissaWidth<T>::VALUE);
          m <<= 1, ++shift)
       ;
     return shift;
   }
 };
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 template <>
-inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
-  sign = bits.getSign();
+inline void NormalFloat<long double>::init_from_bits(FPBits<long double> bits) {
+  sign = bits.get_sign();
 
-  if (bits.isInfOrNaN() || bits.isZero()) {
+  if (bits.is_inf_or_nan() || bits.is_zero()) {
     // Ignore special bit patterns. Implementations deal with them separately
     // anyway so this should not be a problem.
     exponent = 0;
     mantissa = 0;
     return;
   }
 
-  if (bits.getUnbiasedExponent() == 0) {
-    if (bits.getImplicitBit() == 0) {
+  if (bits.get_unbiased_exponent() == 0) {
+    if (bits.get_implicit_bit() == 0) {
       // Since we ignore zero value, the mantissa in this case is non-zero.
-      int normalizationShift = evaluateNormalizationShift(bits.getMantissa());
-      exponent = -16382 - normalizationShift;
-      mantissa = (bits.getMantissa() << normalizationShift);
+      int normalization_shift =
+          evaluate_normalization_shift(bits.get_mantissa());
+      exponent = -16382 - normalization_shift;
+      mantissa = (bits.get_mantissa() << normalization_shift);
     } else {
       exponent = -16382;
-      mantissa = one | bits.getMantissa();
+      mantissa = ONE | bits.get_mantissa();
     }
   } else {
-    if (bits.getImplicitBit() == 0) {
+    if (bits.get_implicit_bit() == 0) {
       // Invalid number so just store 0 similar to a NaN.
       exponent = 0;
       mantissa = 0;
     } else {
-      exponent = bits.getUnbiasedExponent() - 16383;
-      mantissa = one | bits.getMantissa();
+      exponent = bits.get_unbiased_exponent() - 16383;
+      mantissa = ONE | bits.get_mantissa();
     }
   }
 }
 
 template <> inline NormalFloat<long double>::operator long double() const {
-  int biasedExponent = exponent + FPBits<long double>::exponentBias;
+  int biased_exponent = exponent + FPBits<long double>::EXPONENT_BIAS;
   // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
-  constexpr int maxExponentValue = (1 << ExponentWidth<long double>::value) - 2;
-  if (biasedExponent > maxExponentValue) {
-    return sign ? FPBits<long double>::negInf() : FPBits<long double>::inf();
+  constexpr int MAX_EXPONENT_VALUE =
+      (1 << ExponentWidth<long double>::VALUE) - 2;
+  if (biased_exponent > MAX_EXPONENT_VALUE) {
+    return sign ? FPBits<long double>::neg_inf() : FPBits<long double>::inf();
   }
 
   FPBits<long double> result(0.0l);
-  result.setSign(sign);
+  result.set_sign(sign);
 
-  constexpr int subnormalExponent = -FPBits<long double>::exponentBias + 1;
-  if (exponent < subnormalExponent) {
-    unsigned shift = subnormalExponent - exponent;
-    if (shift <= MantissaWidth<long double>::value + 1) {
+  constexpr int SUBNORMAL_EXPONENT = -FPBits<long double>::EXPONENT_BIAS + 1;
+  if (exponent < SUBNORMAL_EXPONENT) {
+    unsigned shift = SUBNORMAL_EXPONENT - exponent;
+    if (shift <= MantissaWidth<long double>::VALUE + 1) {
       // Generate a subnormal number. Might lead to loss of precision.
       // We round to nearest and round halfway cases to even.
-      const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
-      const UIntType shiftOutValue = mantissa & shiftOutMask;
-      const UIntType halfwayValue = UIntType(1) << (shift - 1);
-      result.setUnbiasedExponent(0);
-      result.setMantissa(mantissa >> shift);
-      UIntType newMantissa = result.getMantissa();
-      if (shiftOutValue > halfwayValue) {
-        newMantissa += 1;
-      } else if (shiftOutValue == halfwayValue) {
+      const UIntType shift_out_mask = (UIntType(1) << shift) - 1;
+      const UIntType shift_out_value = mantissa & shift_out_mask;
+      const UIntType halfway_value = UIntType(1) << (shift - 1);
+      result.set_unbiased_exponent(0);
+      result.set_mantissa(mantissa >> shift);
+      UIntType new_mantissa = result.get_mantissa();
+      if (shift_out_value > halfway_value) {
+        new_mantissa += 1;
+      } else if (shift_out_value == halfway_value) {
         // Round to even.
-        if (result.getMantissa() & 0x1)
-          newMantissa += 1;
+        if (result.get_mantissa() & 0x1)
+          new_mantissa += 1;
       }
-      result.setMantissa(newMantissa);
+      result.set_mantissa(new_mantissa);
       // Adding 1 to mantissa can lead to overflow. This can only happen if
       // mantissa was all ones (0b111..11). For such a case, we will carry
       // the overflow into the exponent and set the implicit bit to 1.
-      if (newMantissa == one) {
-        result.setUnbiasedExponent(1);
-        result.setImplicitBit(1);
+      if (new_mantissa == ONE) {
+        result.set_unbiased_exponent(1);
+        result.set_implicit_bit(1);
       } else {
-        result.setImplicitBit(0);
+        result.set_implicit_bit(0);
       }
       return static_cast<long double>(result);
     } else {
       return static_cast<long double>(result);
     }
   }
 
-  result.setUnbiasedExponent(biasedExponent);
-  result.setMantissa(mantissa);
-  result.setImplicitBit(1);
+  result.set_unbiased_exponent(biased_exponent);
+  result.set_mantissa(mantissa);
+  result.set_implicit_bit(1);
   return static_cast<long double>(result);
 }
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H

libc/src/__support/FPUtil/Sqrt.h

 } // namespace internal
 
 // Correctly rounded IEEE 754 SQRT with round to nearest, ties to even.
 // Shift-and-add algorithm.
 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T sqrt(T x) {
   using UIntType = typename FPBits<T>::UIntType;
-  constexpr UIntType One = UIntType(1) << MantissaWidth<T>::value;
+  constexpr UIntType One = UIntType(1) << MantissaWidth<T>::VALUE;
 
   FPBits<T> bits(x);
 
-  if (bits.isInfOrNaN()) {
-    if (bits.getSign() && (bits.getMantissa() == 0)) {
+  if (bits.is_inf_or_nan()) {
+    if (bits.get_sign() && (bits.get_mantissa() == 0)) {
       // sqrt(-Inf) = NaN
-      return FPBits<T>::buildNaN(One >> 1);
+      return FPBits<T>::build_nan(One >> 1);
     } else {
       // sqrt(NaN) = NaN
       // sqrt(+Inf) = +Inf
       return x;
     }
-  } else if (bits.isZero()) {
+  } else if (bits.is_zero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
-  } else if (bits.getSign()) {
+  } else if (bits.get_sign()) {
     // sqrt( negative numbers ) = NaN
-    return FPBits<T>::buildNaN(One >> 1);
+    return FPBits<T>::build_nan(One >> 1);
   } else {
-    int xExp = bits.getExponent();
-    UIntType xMant = bits.getMantissa();
+    int xExp = bits.get_exponent();
+    UIntType xMant = bits.get_mantissa();
 
     // Step 1a: Normalize denormal input and append hidden bit to the mantissa
-    if (bits.getUnbiasedExponent() == 0) {
+    if (bits.get_unbiased_exponent() == 0) {
       ++xExp; // let xExp be the correct exponent of One bit.
       internal::normalize<T>(xExp, xMant);
     } else {
       xMant |= One;
     }
 
     // Step 1b: Make sure the exponent is even.
     if (xExp & 1) {
if (bits.is_inf_or_nan()) {
     r <<= 2;
     UIntType tmp = (y << 2) + 1;
     if (r >= tmp) {
       r -= tmp;
       rb = true;
     }
 
     // Remove hidden bit and append the exponent field.
-    xExp = ((xExp >> 1) + FPBits<T>::exponentBias);
+    xExp = ((xExp >> 1) + FPBits<T>::EXPONENT_BIAS);
 
-    y = (y - One) | (static_cast<UIntType>(xExp) << MantissaWidth<T>::value);
+    y = (y - One) | (static_cast<UIntType>(xExp) << MantissaWidth<T>::VALUE);
     // Round to nearest, ties to even
     if (rb && (lsb || (r != 0))) {
       ++y;
     }
 
     return *reinterpret_cast<T *>(&y);
   }
 }

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

struct FEnv {
 
   static void writeControlWord(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
 
   static uint32_t getStatusWord() { return __arm_rsr("fpsr"); }
 
   static void writeStatusWord(uint32_t fpsr) { __arm_wsr("fpsr", fpsr); }
 };
 
-static inline int enableExcept(int excepts) {
+static inline int enable_except(int excepts) {
   uint32_t newExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord |= (newExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
-static inline int disableExcept(int excepts) {
+static inline int disable_except(int excepts) {
   uint32_t disabledExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord &= ~(disabledExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
-static inline int getExcept() {
+static inline int get_except() {
   uint32_t controlWord = FEnv::getControlWord();
   int enabledExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   return FEnv::exceptionStatusToMacro(enabledExcepts);
 }
 
-static inline int clearExcept(int excepts) {
+static inline int clear_except(int excepts) {
   uint32_t statusWord = FEnv::getStatusWord();
   uint32_t toClear = FEnv::getStatusValueForExcept(excepts);
   statusWord &= ~(toClear << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
-static inline int testExcept(int excepts) {
+static inline int test_except(int excepts) {
   uint32_t toTest = FEnv::getStatusValueForExcept(excepts);
   uint32_t statusWord = FEnv::getStatusWord();
   return FEnv::exceptionStatusToMacro(
       (statusWord >> FEnv::ExceptionStatusFlagsBitPosition) & toTest);
 }
 
-static inline int setExcept(int excepts) {
+static inline int set_except(int excepts) {
   uint32_t statusWord = FEnv::getControlWord();
   uint32_t statusValue = FEnv::getStatusValueForExcept(excepts);
   statusWord |= (statusValue << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
-static inline int raiseExcept(int excepts) {
+static inline int raise_except(int excepts) {
   float zero = 0.0f;
   float one = 1.0f;
-  float largeValue = float(FPBits<float>(FPBits<float>::maxNormal));
-  float smallValue = float(FPBits<float>(FPBits<float>::minNormal));
+  float largeValue = float(FPBits<float>(FPBits<float>::MAX_NORMAL));
+  float smallValue = float(FPBits<float>(FPBits<float>::MIN_NORMAL));
   auto divfunc = [](float a, float b) {
     __asm__ __volatile__("ldr  s0, %0\n\t"
                          "ldr  s1, %1\n\t"
                          "fdiv s0, s0, s1\n\t"
                          : // No outputs
                          : "m"(a), "m"(b)
                          : "s0", "s1" /* s0 and s1 are clobbered */);
   };
if (toRaise & FEnv::Inexact) {
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::Inexact))
       return -1;
   }
   return 0;
 }
 
-static inline int getRound() {
+static inline int get_round() {
   uint32_t roundingMode =
       (FEnv::getControlWord() >> FEnv::RoundingControlBitPosition) & 0x3;
   switch (roundingMode) {
   case FEnv::ToNearest:
     return FE_TONEAREST;
   case FEnv::Downward:
     return FE_DOWNWARD;
   case FEnv::Upward:
     return FE_UPWARD;
   case FEnv::TowardZero:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
-static inline int setRound(int mode) {
+static inline int set_round(int mode) {
   uint16_t bitValue;
   switch (mode) {
   case FE_TONEAREST:
     bitValue = FEnv::ToNearest;
     break;
   case FE_DOWNWARD:
     bitValue = FEnv::Downward;
     break;
static inline int set_round(int mode) {
   uint32_t controlWord = FEnv::getControlWord();
   controlWord &= ~(0x3 << FEnv::RoundingControlBitPosition);
   controlWord |= (bitValue << FEnv::RoundingControlBitPosition);
   FEnv::writeControlWord(controlWord);
 
   return 0;
 }
 
-static inline int getEnv(fenv_t *envp) {
+static inline int get_env(fenv_t *envp) {
   FEnv::FPState *state = reinterpret_cast<FEnv::FPState *>(envp);
   state->ControlWord = FEnv::getControlWord();
   state->StatusWord = FEnv::getStatusWord();
   return 0;
 }
 
-static inline int setEnv(const fenv_t *envp) {
+static inline int set_env(const fenv_t *envp) {
   if (envp == FE_DFL_ENV) {
     // Default status and control words bits are all zeros so we just
     // write zeros.
     FEnv::writeStatusWord(0);
     FEnv::writeControlWord(0);
     return 0;
   }
   const FEnv::FPState *state = reinterpret_cast<const FEnv::FPState *>(envp);

libc/src/__support/FPUtil/generic/FMA.h

 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
                                                                      T z) {
   // Product is exact.
   double prod = static_cast<double>(x) * static_cast<double>(y);
   double z_d = static_cast<double>(z);
   double sum = prod + z_d;
   fputil::FPBits<double> bit_prod(prod), bitz(z_d), bit_sum(sum);
 
-  if (!(bit_sum.isInfOrNaN() || bit_sum.isZero())) {
+  if (!(bit_sum.is_inf_or_nan() || bit_sum.is_zero())) {
     // Since the sum is computed in double precision, rounding might happen
     // (for instance, when bitz.exponent > bit_prod.exponent + 5, or
     // bit_prod.exponent > bitz.exponent + 40).  In that case, when we round
     // the sum back to float, double rounding error might occur.
     // A concrete example of this phenomenon is as follows:
     //   x = y = 1 + 2^(-12), z = 2^(-53)
     // The exact value of x*y + z is 1 + 2^(-11) + 2^(-24) + 2^(-53)
     // So when rounding to float, fmaf(x, y, z) = 1 + 2^(-11) + 2^(-23)
     // On the other hand, with the default rounding mode,
     //   double(x*y + z) = 1 + 2^(-11) + 2^(-24)
     // and casting again to float gives us:
     //   float(double(x*y + z)) = 1 + 2^(-11).
     //
     // In order to correct this possible double rounding error, first we use
     // Dekker's 2Sum algorithm to find t such that sum - t = prod + z exactly,
     // assuming the (default) rounding mode is round-to-the-nearest,
     // tie-to-even.  Moreover, t satisfies the condition that t < eps(sum),
     // i.e., t.exponent < sum.exponent - 52. So if t is not 0, meaning rounding
     // occurs when computing the sum, we just need to use t to adjust (any) last
     // bit of sum, so that the sticky bits used when rounding sum to float are
     // correct (when it matters).
     fputil::FPBits<double> t(
-        (bit_prod.getUnbiasedExponent() >= bitz.getUnbiasedExponent())
+        (bit_prod.get_unbiased_exponent() >= bitz.get_unbiased_exponent())
             ? ((double(bit_sum) - double(bit_prod)) - double(bitz))
             : ((double(bit_sum) - double(bitz)) - double(bit_prod)));
 
     // Update sticky bits if t != 0.0 and the least (52 - 23 - 1 = 28) bits are
     // zero.
-    if (!t.isZero() && ((bit_sum.getMantissa() & 0xfff'ffffULL) == 0)) {
-      if (bit_sum.getSign() != t.getSign()) {
-        bit_sum.setMantissa(bit_sum.getMantissa() + 1);
-      } else if (bit_sum.getMantissa()) {
-        bit_sum.setMantissa(bit_sum.getMantissa() - 1);
+    if (!t.is_zero() && ((bit_sum.get_mantissa() & 0xfff'ffffULL) == 0)) {
+      if (bit_sum.get_sign() != t.get_sign()) {
+        bit_sum.set_mantissa(bit_sum.get_mantissa() + 1);
+      } else if (bit_sum.get_mantissa()) {
+        bit_sum.set_mantissa(bit_sum.get_mantissa() - 1);
       }
     }
   }
 
   return static_cast<float>(static_cast<double>(bit_sum));
 }
 
 } // namespace generic
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H

libc/src/__support/FPUtil/x86_64/FEnvImpl.h

 // such a manner. So, we will define enums corresponding to the x86_64 bit
 // encodings. The implementations can map from FE_* to the corresponding enum
 // values.
 
 // The rounding control values in the x87 control register and the MXCSR
 // register have the same 2-bit enoding but have different bit positions.
 // See below for the bit positions.
 struct RoundingControlValue {
-  static constexpr uint16_t ToNearest = 0x0;
-  static constexpr uint16_t Downward = 0x1;
-  static constexpr uint16_t Upward = 0x2;
-  static constexpr uint16_t TowardZero = 0x3;
+  static constexpr uint16_t TO_NEAREST = 0x0;
+  static constexpr uint16_t DOWNWARD = 0x1;
+  static constexpr uint16_t UPWARD = 0x2;
+  static constexpr uint16_t TOWARD_ZERO = 0x3;
 };
 
-static constexpr uint16_t X87RoundingControlBitPosition = 10;
-static constexpr uint16_t MXCSRRoundingControlBitPosition = 13;
+static constexpr uint16_t X87_ROUNDING_CONTROL_BIT_POSITION = 10;
+static constexpr uint16_t MXCSR_ROUNDING_CONTROL_BIT_POSITION = 13;
 
 // The exception flags in the x87 status register and the MXCSR have the same
 // encoding as well as the same bit positions.
 struct ExceptionFlags {
-  static constexpr uint16_t Invalid = 0x1;
+  static constexpr uint16_t INVALID = 0x1;
   // Some libcs define __FE_DENORM corresponding to the denormal input
   // exception and include it in FE_ALL_EXCEPTS. We define and use it to
   // support compiling against headers provided by such libcs.
-  static constexpr uint16_t Denormal = 0x2;
-  static constexpr uint16_t DivByZero = 0x4;
-  static constexpr uint16_t Overflow = 0x8;
-  static constexpr uint16_t Underflow = 0x10;
-  static constexpr uint16_t Inexact = 0x20;
+  static constexpr uint16_t DENORMAL = 0x2;
+  static constexpr uint16_t DIV_BY_ZERO = 0x4;
+  static constexpr uint16_t OVERFLOW = 0x8;
+  static constexpr uint16_t UNDERFLOW = 0x10;
+  static constexpr uint16_t INEXACT = 0x20;
 };
 
 // The exception control bits occupy six bits, one bit for each exception.
 // In the x87 control word, they occupy the first 6 bits. In the MXCSR
 // register, they occupy bits 7 to 12.
-static constexpr uint16_t X87ExceptionControlBitPosition = 0;
-static constexpr uint16_t MXCSRExceptionContolBitPoistion = 7;
+static constexpr uint16_t X87_EXCEPTION_CONTROL_BIT_POSITION = 0;
+static constexpr uint16_t MXCSR_EXCEPTION_CONTOL_BIT_POISTION = 7;
 
 // Exception flags are individual bits in the corresponding registers.
 // So, we just OR the bit values to get the full set of exceptions.
-static inline uint16_t getStatusValueForExcept(int excepts) {
+static inline uint16_t get_status_value_for_except(int excepts) {
   // We will make use of the fact that exception control bits are single
   // bit flags in the control registers.
-  return (excepts & FE_INVALID ? ExceptionFlags::Invalid : 0) |
+  return (excepts & FE_INVALID ? ExceptionFlags::INVALID : 0) |
 #ifdef __FE_DENORM
          (excepts & __FE_DENORM ? ExceptionFlags::Denormal : 0) |
 #endif // __FE_DENORM
-         (excepts & FE_DIVBYZERO ? ExceptionFlags::DivByZero : 0) |
-         (excepts & FE_OVERFLOW ? ExceptionFlags::Overflow : 0) |
-         (excepts & FE_UNDERFLOW ? ExceptionFlags::Underflow : 0) |
-         (excepts & FE_INEXACT ? ExceptionFlags::Inexact : 0);
+         (excepts & FE_DIVBYZERO ? ExceptionFlags::DIV_BY_ZERO : 0) |
+         (excepts & FE_OVERFLOW ? ExceptionFlags::OVERFLOW : 0) |
+         (excepts & FE_UNDERFLOW ? ExceptionFlags::UNDERFLOW : 0) |
+         (excepts & FE_INEXACT ? ExceptionFlags::INEXACT : 0);
 }
 
-static inline int exceptionStatusToMacro(uint16_t status) {
-  return (status & ExceptionFlags::Invalid ? FE_INVALID : 0) |
+static inline int exception_status_to_macro(uint16_t status) {
+  return (status & ExceptionFlags::INVALID ? FE_INVALID : 0) |
 #ifdef __FE_DENORM
          (status & ExceptionFlags::Denormal ? __FE_DENORM : 0) |
 #endif // __FE_DENORM
-         (status & ExceptionFlags::DivByZero ? FE_DIVBYZERO : 0) |
-         (status & ExceptionFlags::Overflow ? FE_OVERFLOW : 0) |
-         (status & ExceptionFlags::Underflow ? FE_UNDERFLOW : 0) |
-         (status & ExceptionFlags::Inexact ? FE_INEXACT : 0);
+         (status & ExceptionFlags::DIV_BY_ZERO ? FE_DIVBYZERO : 0) |
+         (status & ExceptionFlags::OVERFLOW ? FE_OVERFLOW : 0) |
+         (status & ExceptionFlags::UNDERFLOW ? FE_UNDERFLOW : 0) |
+         (status & ExceptionFlags::INEXACT ? FE_INEXACT : 0);
 }
 
 struct X87StateDescriptor {
-  uint16_t ControlWord;
-  uint16_t Unused1;
-  uint16_t StatusWord;
-  uint16_t Unused2;
+  uint16_t control_word;
+  uint16_t unused1;
+  uint16_t status_word;
+  uint16_t unused2;
   // TODO: Elaborate the remaining 20 bytes as required.
   uint32_t _[5];
 };
 
-static inline uint16_t getX87ControlWord() {
+static inline uint16_t get_x87_control_word() {
   uint16_t w;
   __asm__ __volatile__("fnstcw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void writeX87ControlWord(uint16_t w) {
+static inline void write_x87_control_word(uint16_t w) {
   __asm__ __volatile__("fldcw %0" : : "m"(w) :);
 }
 
-static inline uint16_t getX87StatusWord() {
+static inline uint16_t get_x87_status_word() {
   uint16_t w;
   __asm__ __volatile__("fnstsw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void clearX87Exceptions() {
+static inline void clear_x87_exceptions() {
   __asm__ __volatile__("fnclex" : : :);
 }
 
-static inline uint32_t getMXCSR() {
+static inline uint32_t get_mxcsr() {
   uint32_t w;
   __asm__ __volatile__("stmxcsr %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void writeMXCSR(uint32_t w) {
+static inline void write_mxcsr(uint32_t w) {
   __asm__ __volatile__("ldmxcsr %0" : : "m"(w) :);
 }
 
-static inline void getX87StateDescriptor(X87StateDescriptor &s) {
+static inline void get_x87_state_descriptor(X87StateDescriptor &s) {
   __asm__ __volatile__("fnstenv %0" : "=m"(s));
   SANITIZER_MEMORY_INITIALIZED(&s, sizeof(s));
 }
 
-static inline void writeX87StateDescriptor(const X87StateDescriptor &s) {
+static inline void write_x87_state_descriptor(const X87StateDescriptor &s) {
   __asm__ __volatile__("fldenv %0" : : "m"(s) :);
 }
 
 static inline void fwait() { __asm__ __volatile__("fwait"); }
 
 } // namespace internal
 
-static inline int enableExcept(int excepts) {
+static inline int enable_except(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set. That is the reason for all the
   // bit-flip operations below as we need to turn the bits to zero
   // to enable them.
 
-  uint16_t bitMask = internal::getStatusValueForExcept(excepts);
+  uint16_t bit_mask = internal::get_status_value_for_except(excepts);
 
-  uint16_t x87CW = internal::getX87ControlWord();
-  uint16_t oldExcepts = ~x87CW & 0x3F; // Save previously enabled exceptions.
-  x87CW &= ~bitMask;
-  internal::writeX87ControlWord(x87CW);
+  uint16_t x87_cw = internal::get_x87_control_word();
+  uint16_t old_excepts = ~x87_cw & 0x3F; // Save previously enabled exceptions.
+  x87_cw &= ~bit_mask;
+  internal::write_x87_control_word(x87_cw);
 
   // Enabling SSE exceptions via MXCSR is a nice thing to do but
   // might not be of much use practically as SSE exceptions and the x87
   // exceptions are independent of each other.
-  uint32_t mxcsr = internal::getMXCSR();
-  mxcsr &= ~(bitMask << internal::MXCSRExceptionContolBitPoistion);
-  internal::writeMXCSR(mxcsr);
+  uint32_t mxcsr = internal::get_mxcsr();
+  mxcsr &= ~(bit_mask << internal::MXCSR_EXCEPTION_CONTOL_BIT_POISTION);
+  internal::write_mxcsr(mxcsr);
 
   // Since the x87 exceptions and SSE exceptions are independent of each,
   // it doesn't make much sence to report both in the return value. Most
   // often, the standard floating point functions deal with FPU operations
   // so we will retrun only the old x87 exceptions.
-  return internal::exceptionStatusToMacro(oldExcepts);
+  return internal::exception_status_to_macro(old_excepts);
 }
 
-static inline int disableExcept(int excepts) {
+static inline int disable_except(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set.
 
-  uint16_t bitMask = internal::getStatusValueForExcept(excepts);
+  uint16_t bit_mask = internal::get_status_value_for_except(excepts);
 
-  uint16_t x87CW = internal::getX87ControlWord();
-  uint16_t oldExcepts = ~x87CW & 0x3F; // Save previously enabled exceptions.
-  x87CW |= bitMask;
-  internal::writeX87ControlWord(x87CW);
+  uint16_t x87_cw = internal::get_x87_control_word();
+  uint16_t old_excepts = ~x87_cw & 0x3F; // Save previously enabled exceptions.
+  x87_cw |= bit_mask;
+  internal::write_x87_control_word(x87_cw);
 
-  // Just like in enableExcept, it is not clear if disabling SSE exceptions
+  // Just like in enable_except, it is not clear if disabling SSE exceptions
   // is required. But, we will still do it only as a "nice thing to do".
-  uint32_t mxcsr = internal::getMXCSR();
-  mxcsr |= (bitMask << internal::MXCSRExceptionContolBitPoistion);
-  internal::writeMXCSR(mxcsr);
+  uint32_t mxcsr = internal::get_mxcsr();
+  mxcsr |= (bit_mask << internal::MXCSR_EXCEPTION_CONTOL_BIT_POISTION);
+  internal::write_mxcsr(mxcsr);
 
-  return internal::exceptionStatusToMacro(oldExcepts);
+  return internal::exception_status_to_macro(old_excepts);
 }
 
-static inline int getExcept() {
-  uint16_t x87CW = internal::getX87ControlWord();
-  uint16_t enabledExcepts = ~x87CW & 0x3F;
-  return internal::exceptionStatusToMacro(enabledExcepts);
+static inline int get_except() {
+  uint16_t x87_cw = internal::get_x87_control_word();
+  uint16_t enabled_excepts = ~x87_cw & 0x3F;
+  return internal::exception_status_to_macro(enabled_excepts);
 }
 
-static inline int clearExcept(int excepts) {
+static inline int clear_except(int excepts) {
   internal::X87StateDescriptor state;
-  internal::getX87StateDescriptor(state);
-  state.StatusWord &= ~internal::getStatusValueForExcept(excepts);
-  internal::writeX87StateDescriptor(state);
-
-  uint32_t mxcsr = internal::getMXCSR();
-  mxcsr &= ~internal::getStatusValueForExcept(excepts);
-  internal::writeMXCSR(mxcsr);
+  internal::get_x87_state_descriptor(state);
+  state.status_word &= ~internal::get_status_value_for_except(excepts);
+  internal::write_x87_state_descriptor(state);
+
+  uint32_t mxcsr = internal::get_mxcsr();
+  mxcsr &= ~internal::get_status_value_for_except(excepts);
+  internal::write_mxcsr(mxcsr);
   return 0;
 }
 
-static inline int testExcept(int excepts) {
-  uint16_t statusValue = internal::getStatusValueForExcept(excepts);
+static inline int test_except(int excepts) {
+  uint16_t status_value = internal::get_status_value_for_except(excepts);
   // Check both x87 status word and MXCSR.
-  return internal::exceptionStatusToMacro(
-      (statusValue & internal::getX87StatusWord()) |
-      (statusValue & internal::getMXCSR()));
+  return internal::exception_status_to_macro(
+      (status_value & internal::get_x87_status_word()) |
+      (status_value & internal::get_mxcsr()));
 }
 
 // Sets the exception flags but does not trigger the exception handler.
-static inline int setExcept(int excepts) {
-  uint16_t statusValue = internal::getStatusValueForExcept(excepts);
+static inline int set_except(int excepts) {
+  uint16_t status_value = internal::get_status_value_for_except(excepts);
   internal::X87StateDescriptor state;
-  internal::getX87StateDescriptor(state);
-  state.StatusWord |= statusValue;
-  internal::writeX87StateDescriptor(state);
-
-  uint32_t mxcsr = internal::getMXCSR();
-  mxcsr |= statusValue;
-  internal::writeMXCSR(mxcsr);
+  internal::get_x87_state_descriptor(state);
+  state.status_word |= status_value;
+  internal::write_x87_state_descriptor(state);
+
+  uint32_t mxcsr = internal::get_mxcsr();
+  mxcsr |= status_value;
+  internal::write_mxcsr(mxcsr);
 
   return 0;
 }
 
-static inline int raiseExcept(int excepts) {
-  uint16_t statusValue = internal::getStatusValueForExcept(excepts);
+static inline int raise_except(int excepts) {
+  uint16_t status_value = internal::get_status_value_for_except(excepts);
 
   // We set the status flag for exception one at a time and call the
   // fwait instruction to actually get the processor to raise the
   // exception by calling the exception handler. This scheme is per
   // the description in in "8.6 X87 FPU EXCEPTION SYNCHRONIZATION"
   // of the "Intel 64 and IA-32 Architectures Software Developer's
   // Manual, Vol 1".
 
   // FPU status word is read for each exception seperately as the
   // exception handler can potentially write to it (typically to clear
   // the corresponding exception flag). By reading it separately, we
   // ensure that the writes by the exception handler are maintained
   // when raising the next exception.
 
-  auto raiseHelper = [](uint16_t singleExceptFlag) {
+  auto raise_helper = [](uint16_t singleExceptFlag) {
     internal::X87StateDescriptor state;
-    internal::getX87StateDescriptor(state);
-    state.StatusWord |= singleExceptFlag;
-    internal::writeX87StateDescriptor(state);
+    internal::get_x87_state_descriptor(state);
+    state.status_word |= singleExceptFlag;
+    internal::write_x87_state_descriptor(state);
     internal::fwait();
   };
 
-  if (statusValue & internal::ExceptionFlags::Invalid)
-    raiseHelper(internal::ExceptionFlags::Invalid);
-  if (statusValue & internal::ExceptionFlags::DivByZero)
-    raiseHelper(internal::ExceptionFlags::DivByZero);
-  if (statusValue & internal::ExceptionFlags::Overflow)
-    raiseHelper(internal::ExceptionFlags::Overflow);
-  if (statusValue & internal::ExceptionFlags::Underflow)
-    raiseHelper(internal::ExceptionFlags::Underflow);
-  if (statusValue & internal::ExceptionFlags::Inexact)
-    raiseHelper(internal::ExceptionFlags::Inexact);
+  if (status_value & internal::ExceptionFlags::INVALID)
+    raise_helper(internal::ExceptionFlags::INVALID);
+  if (status_value & internal::ExceptionFlags::DIV_BY_ZERO)
+    raise_helper(internal::ExceptionFlags::DIV_BY_ZERO);
+  if (status_value & internal::ExceptionFlags::OVERFLOW)
+    raise_helper(internal::ExceptionFlags::OVERFLOW);
+  if (status_value & internal::ExceptionFlags::UNDERFLOW)
+    raise_helper(internal::ExceptionFlags::UNDERFLOW);
+  if (status_value & internal::ExceptionFlags::INEXACT)
+    raise_helper(internal::ExceptionFlags::INEXACT);
 #ifdef __FE_DENORM
   if (statusValue & internal::ExceptionFlags::Denormal) {
     raiseHelper(internal::ExceptionFlags::Denormal);
   }
 #endif // __FE_DENORM
 
   // There is no special synchronization scheme available to
   // raise SEE exceptions. So, we will ignore that for now.
   // Just plain writing to the MXCSR register does not guarantee
   // the exception handler will be called.
 
   return 0;
 }
 
-static inline int getRound() {
-  uint16_t bitValue =
-      (internal::getMXCSR() >> internal::MXCSRRoundingControlBitPosition) & 0x3;
-  switch (bitValue) {
-  case internal::RoundingControlValue::ToNearest:
+static inline int get_round() {
+  uint16_t bit_value =
+      (internal::get_mxcsr() >> internal::MXCSR_ROUNDING_CONTROL_BIT_POSITION) &
+      0x3;
+  switch (bit_value) {
+  case internal::RoundingControlValue::TO_NEAREST:
     return FE_TONEAREST;
-  case internal::RoundingControlValue::Downward:
+  case internal::RoundingControlValue::DOWNWARD:
     return FE_DOWNWARD;
-  case internal::RoundingControlValue::Upward:
+  case internal::RoundingControlValue::UPWARD:
     return FE_UPWARD;
-  case internal::RoundingControlValue::TowardZero:
+  case internal::RoundingControlValue::TOWARD_ZERO:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
-static inline int setRound(int mode) {
-  uint16_t bitValue;
+static inline int set_round(int mode) {
+  uint16_t bit_value;
   switch (mode) {
   case FE_TONEAREST:
-    bitValue = internal::RoundingControlValue::ToNearest;
+    bit_value = internal::RoundingControlValue::TO_NEAREST;
     break;
   case FE_DOWNWARD:
-    bitValue = internal::RoundingControlValue::Downward;
+    bit_value = internal::RoundingControlValue::DOWNWARD;
     break;
   case FE_UPWARD:
-    bitValue = internal::RoundingControlValue::Upward;
+    bit_value = internal::RoundingControlValue::UPWARD;
     break;
   case FE_TOWARDZERO:
-    bitValue = internal::RoundingControlValue::TowardZero;
+    bit_value = internal::RoundingControlValue::TOWARD_ZERO;
     break;
   default:
     return 1; // To indicate failure
   }
 
-  uint16_t x87Value = static_cast<uint16_t>(
-      bitValue << internal::X87RoundingControlBitPosition);
-  uint16_t x87Control = internal::getX87ControlWord();
-  x87Control = static_cast<uint16_t>(
-      (x87Control &
-       ~(uint16_t(0x3) << internal::X87RoundingControlBitPosition)) |
-      x87Value);
-  internal::writeX87ControlWord(x87Control);
-
-  uint32_t mxcsrValue = bitValue << internal::MXCSRRoundingControlBitPosition;
-  uint32_t mxcsrControl = internal::getMXCSR();
-  mxcsrControl =
-      (mxcsrControl & ~(0x3 << internal::MXCSRRoundingControlBitPosition)) |
-      mxcsrValue;
-  internal::writeMXCSR(mxcsrControl);
+  uint16_t x87_value = static_cast<uint16_t>(
+      bit_value << internal::X87_ROUNDING_CONTROL_BIT_POSITION);
+  uint16_t x87_control = internal::get_x87_control_word();
+  x87_control = static_cast<uint16_t>(
+      (x87_control &
+       ~(uint16_t(0x3) << internal::X87_ROUNDING_CONTROL_BIT_POSITION)) |
+      x87_value);
+  internal::write_x87_control_word(x87_control);
+
+  uint32_t mxcsr_value = bit_value
+                         << internal::MXCSR_ROUNDING_CONTROL_BIT_POSITION;
+  uint32_t mxcsr_control = internal::get_mxcsr();
+  mxcsr_control = (mxcsr_control &
+                   ~(0x3 << internal::MXCSR_ROUNDING_CONTROL_BIT_POSITION)) |
+                  mxcsr_value;
+  internal::write_mxcsr(mxcsr_control);
 
   return 0;
 }
 
 namespace internal {
 
 #ifdef _WIN32
 // MSVC fenv.h defines a very simple representation of the floating point state
 // which just consists of control and status words of the x87 unit.
 struct FPState {
   uint32_t ControlWord;
   uint32_t StatusWord;
 };
 #else
 struct FPState {
-  X87StateDescriptor X87Status;
-  uint32_t MXCSR;
+  X87StateDescriptor x87_status;
+  uint32_t mxcsr;
 };
 #endif // _WIN32
 
 } // namespace internal
 
 static_assert(
     sizeof(fenv_t) == sizeof(internal::FPState),
     "Internal floating point state does not match the public fenv_t type.");
 
 #ifdef _WIN32
-static inline int getEnv(fenv_t *envp) {
+static inline int get_env(fenv_t *envp) {
   internal::FPState *state = reinterpret_cast<internal::FPState *>(envp);
   internal::X87StateDescriptor X87Status;
   internal::getX87StateDescriptor(X87Status);
   state->ControlWord = X87Status.ControlWord;
   state->StatusWord = X87Status.StatusWord;
   return 0;
 }
 
-static inline int setEnv(const fenv_t *envp) {
+static inline int set_env(const fenv_t *envp) {
   const internal::FPState *state =
       reinterpret_cast<const internal::FPState *>(envp);
   internal::X87StateDescriptor X87Status;
   X87Status.ControlWord = state->ControlWord;
   X87Status.StatusWord = state->StatusWord;
   internal::writeX87StateDescriptor(X87Status);
   return 0;
 }
 #else
-static inline int getEnv(fenv_t *envp) {
+static inline int get_env(fenv_t *envp) {
   internal::FPState *state = reinterpret_cast<internal::FPState *>(envp);
-  internal::getX87StateDescriptor(state->X87Status);
-  state->MXCSR = internal::getMXCSR();
+  internal::get_x87_state_descriptor(state->x87_status);
+  state->mxcsr = internal::get_mxcsr();
   return 0;
 }
 
-static inline int setEnv(const fenv_t *envp) {
+static inline int set_env(const fenv_t *envp) {
   // envp contains everything including pieces like the current
   // top of FPU stack. We cannot arbitrarily change them. So, we first
   // read the current status and update only those pieces which are
   // not disruptive.
-  internal::X87StateDescriptor x87Status;
-  internal::getX87StateDescriptor(x87Status);
+  internal::X87StateDescriptor x87_status;
+  internal::get_x87_state_descriptor(x87_status);
 
   if (envp == FE_DFL_ENV) {
     // Reset the exception flags in the status word.
-    x87Status.StatusWord &= ~uint16_t(0x3F);
+    x87_status.status_word &= ~uint16_t(0x3F);
     // Reset other non-sensitive parts of the status word.
     for (int i = 0; i < 5; i++)
-      x87Status._[i] = 0;
+      x87_status._[i] = 0;
     // In the control word, we do the following:
     // 1. Mask all exceptions
     // 2. Set rounding mode to round-to-nearest
     // 3. Set the internal precision to double extended precision.
-    x87Status.ControlWord |= uint16_t(0x3F);         // Mask all exceptions.
-    x87Status.ControlWord &= ~(uint16_t(0x3) << 10); // Round to nearest.
-    x87Status.ControlWord |= (uint16_t(0x3) << 8);   // Extended precision.
-    internal::writeX87StateDescriptor(x87Status);
+    x87_status.control_word |= uint16_t(0x3F);         // Mask all exceptions.
+    x87_status.control_word &= ~(uint16_t(0x3) << 10); // Round to nearest.
+    x87_status.control_word |= (uint16_t(0x3) << 8);   // Extended precision.
+    internal::write_x87_state_descriptor(x87_status);
 
     // We take the exact same approach MXCSR register as well.
     // MXCSR has two additional fields, "flush-to-zero" and
     // "denormals-are-zero". We reset those bits. Also, MXCSR does not
     // have a field which controls the precision of internal operations.
-    uint32_t mxcsr = internal::getMXCSR();
+    uint32_t mxcsr = internal::get_mxcsr();
     mxcsr &= ~uint16_t(0x3F);        // Clear exception flags.
     mxcsr &= ~(uint16_t(0x1) << 6);  // Reset denormals-are-zero
     mxcsr |= (uint16_t(0x3F) << 7);  // Mask exceptions
     mxcsr &= ~(uint16_t(0x3) << 13); // Round to nearest.
     mxcsr &= ~(uint16_t(0x1) << 15); // Reset flush-to-zero
-    internal::writeMXCSR(mxcsr);
+    internal::write_mxcsr(mxcsr);
 
     return 0;
   }
 
   const internal::FPState *fpstate =
       reinterpret_cast<const internal::FPState *>(envp);
 
   // Copy the exception status flags from envp.
-  x87Status.StatusWord &= ~uint16_t(0x3F);
-  x87Status.StatusWord |= (fpstate->X87Status.StatusWord & 0x3F);
+  x87_status.status_word &= ~uint16_t(0x3F);
+  x87_status.status_word |= (fpstate->x87_status.status_word & 0x3F);
   // Copy other non-sensitive parts of the status word.
   for (int i = 0; i < 5; i++)
-    x87Status._[i] = fpstate->X87Status._[i];
+    x87_status._[i] = fpstate->x87_status._[i];
   // We can set the x87 control word as is as there no sensitive bits.
-  x87Status.ControlWord = fpstate->X87Status.ControlWord;
-  internal::writeX87StateDescriptor(x87Status);
+  x87_status.control_word = fpstate->x87_status.control_word;
+  internal::write_x87_state_descriptor(x87_status);
 
   // We can write the MXCSR state as is as there are no sensitive bits.
-  internal::writeMXCSR(fpstate->MXCSR);
+  internal::write_mxcsr(fpstate->mxcsr);
   return 0;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <unsigned Width> struct Padding;
 
 // i386 padding.
-template <> struct Padding<4> { static constexpr unsigned value = 16; };
+template <> struct Padding<4> { static constexpr unsigned VALUE = 16; };
 
 // x86_64 padding.
-template <> struct Padding<8> { static constexpr unsigned value = 48; };
+template <> struct Padding<8> { static constexpr unsigned VALUE = 48; };
 
 template <> union FPBits<long double> {
   using UIntType = __uint128_t;
 
-  static constexpr int exponentBias = 0x3FFF;
-  static constexpr int maxExponent = 0x7FFF;
-  static constexpr UIntType minSubnormal = UIntType(1);
+  static constexpr int EXPONENT_BIAS = 0x3FFF;
+  static constexpr int MAX_EXPONENT = 0x7FFF;
+  static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
   // Subnormal numbers include the implicit bit in x86 long double formats.
-  static constexpr UIntType maxSubnormal =
-      (UIntType(1) << (MantissaWidth<long double>::value)) - 1;
-  static constexpr UIntType minNormal =
-      (UIntType(3) << MantissaWidth<long double>::value);
-  static constexpr UIntType maxNormal =
-      ((UIntType(maxExponent) - 1) << (MantissaWidth<long double>::value + 1)) |
-      (UIntType(1) << MantissaWidth<long double>::value) | maxSubnormal;
+  static constexpr UIntType MAX_SUBNORMAL =
+      (UIntType(1) << (MantissaWidth<long double>::VALUE)) - 1;
+  static constexpr UIntType MIN_NORMAL =
+      (UIntType(3) << MantissaWidth<long double>::VALUE);
+  static constexpr UIntType MAX_NORMAL =
+      ((UIntType(MAX_EXPONENT) - 1)
+       << (MantissaWidth<long double>::VALUE + 1)) |
+      (UIntType(1) << MantissaWidth<long double>::VALUE) | MAX_SUBNORMAL;
 
   using FloatProp = FloatProperties<long double>;
 
   UIntType bits;
 
-  void setMantissa(UIntType mantVal) {
-    mantVal &= (FloatProp::mantissaMask);
-    bits &= ~(FloatProp::mantissaMask);
+  void set_mantissa(UIntType mantVal) {
+    mantVal &= (FloatProp::MANTISSA_MASK);
+    bits &= ~(FloatProp::MANTISSA_MASK);
     bits |= mantVal;
   }
 
-  UIntType getMantissa() const { return bits & FloatProp::mantissaMask; }
+  UIntType get_mantissa() const { return bits & FloatProp::MANTISSA_MASK; }
 
-  void setUnbiasedExponent(UIntType expVal) {
-    expVal = (expVal << (FloatProp::bitWidth - 1 - FloatProp::exponentWidth)) &
-             FloatProp::exponentMask;
-    bits &= ~(FloatProp::exponentMask);
+  void set_unbiased_exponent(UIntType expVal) {
+    expVal =
+        (expVal << (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH)) &
+        FloatProp::EXPONENT_MASK;
+    bits &= ~(FloatProp::EXPONENT_MASK);
     bits |= expVal;
   }
 
-  uint16_t getUnbiasedExponent() const {
-    return uint16_t((bits & FloatProp::exponentMask) >>
-                    (FloatProp::bitWidth - 1 - FloatProp::exponentWidth));
+  uint16_t get_unbiased_exponent() const {
+    return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
+                    (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH));
   }
 
-  void setImplicitBit(bool implicitVal) {
-    bits &= ~(UIntType(1) << FloatProp::mantissaWidth);
-    bits |= (UIntType(implicitVal) << FloatProp::mantissaWidth);
+  void set_implicit_bit(bool implicitVal) {
+    bits &= ~(UIntType(1) << FloatProp::MANTISSA_WIDTH);
+    bits |= (UIntType(implicitVal) << FloatProp::MANTISSA_WIDTH);
   }
 
-  bool getImplicitBit() const {
-    return ((bits & (UIntType(1) << FloatProp::mantissaWidth)) >>
-            FloatProp::mantissaWidth);
+  bool get_implicit_bit() const {
+    return ((bits & (UIntType(1) << FloatProp::MANTISSA_WIDTH)) >>
+            FloatProp::MANTISSA_WIDTH);
   }
 
-  void setSign(bool signVal) {
-    bits &= ~(FloatProp::signMask);
-    UIntType sign1 = UIntType(signVal) << (FloatProp::bitWidth - 1);
+  void set_sign(bool signVal) {
+    bits &= ~(FloatProp::SIGN_MASK);
+    UIntType sign1 = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
     bits |= sign1;
   }
 
-  bool getSign() const {
-    return ((bits & FloatProp::signMask) >> (FloatProp::bitWidth - 1));
+  bool get_sign() const {
+    return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
   }
 
   long double val;
 
   FPBits() : bits(0) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
   explicit FPBits(XType x) : val(x) {
     // bits starts uninitialized, and setting it to a long double only
     // overwrites the first 80 bits. This clears those upper bits.
     bits = bits & ((UIntType(1) << 80) - 1);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
   operator long double() { return val; }
 
   UIntType uintval() {
     // We zero the padding bits as they can contain garbage.
-    static constexpr UIntType mask =
+    static constexpr UIntType MASK =
         (UIntType(1) << (sizeof(long double) * 8 -
-                         Padding<sizeof(uintptr_t)>::value)) -
+                         Padding<sizeof(uintptr_t)>::VALUE)) -
         1;
-    return bits & mask;
+    return bits & MASK;
   }
 
-  int getExponent() const {
-    if (getUnbiasedExponent() == 0)
-      return int(1) - exponentBias;
-    return int(getUnbiasedExponent()) - exponentBias;
+  int get_exponent() const {
+    if (get_unbiased_exponent() == 0)
+      return int(1) - EXPONENT_BIAS;
+    return int(get_unbiased_exponent()) - EXPONENT_BIAS;
   }
 
-  bool isZero() const {
-    return getUnbiasedExponent() == 0 && getMantissa() == 0 &&
-           getImplicitBit() == 0;
+  bool is_zero() const {
+    return get_unbiased_exponent() == 0 && get_mantissa() == 0 &&
+           get_implicit_bit() == 0;
   }
 
-  bool isInf() const {
-    return getUnbiasedExponent() == maxExponent && getMantissa() == 0 &&
-           getImplicitBit() == 1;
+  bool is_inf() const {
+    return get_unbiased_exponent() == MAX_EXPONENT && get_mantissa() == 0 &&
+           get_implicit_bit() == 1;
   }
 
-  bool isNaN() const {
-    if (getUnbiasedExponent() == maxExponent) {
-      return (getImplicitBit() == 0) || getMantissa() != 0;
-    } else if (getUnbiasedExponent() != 0) {
-      return getImplicitBit() == 0;
+  bool is_nan() const {
+    if (get_unbiased_exponent() == MAX_EXPONENT) {
+      return (get_implicit_bit() == 0) || get_mantissa() != 0;
+    } else if (get_unbiased_exponent() != 0) {
+      return get_implicit_bit() == 0;
     }
     return false;
   }
 
-  bool isInfOrNaN() const {
-    return (getUnbiasedExponent() == maxExponent) ||
-           (getUnbiasedExponent() != 0 && getImplicitBit() == 0);
+  bool is_inf_or_nan() const {
+    return (get_unbiased_exponent() == MAX_EXPONENT) ||
+           (get_unbiased_exponent() != 0 && get_implicit_bit() == 0);
   }
 
   // Methods below this are used by tests.
 
   static FPBits<long double> zero() { return FPBits<long double>(0.0l); }
 
-  static FPBits<long double> negZero() {
+  static FPBits<long double> neg_zero() {
     FPBits<long double> bits(0.0l);
-    bits.setSign(1);
+    bits.set_sign(1);
     return bits;
   }
 
   static FPBits<long double> inf() {
     FPBits<long double> bits(0.0l);
-    bits.setUnbiasedExponent(maxExponent);
-    bits.setImplicitBit(1);
+    bits.set_unbiased_exponent(MAX_EXPONENT);
+    bits.set_implicit_bit(1);
     return bits;
   }
 
-  static FPBits<long double> negInf() {
+  static FPBits<long double> neg_inf() {
     FPBits<long double> bits(0.0l);
-    bits.setUnbiasedExponent(maxExponent);
-    bits.setImplicitBit(1);
-    bits.setSign(1);
+    bits.set_unbiased_exponent(MAX_EXPONENT);
+    bits.set_implicit_bit(1);
+    bits.set_sign(1);
     return bits;
   }
 
-  static long double buildNaN(UIntType v) {
+  static long double build_nan(UIntType v) {
     FPBits<long double> bits(0.0l);
-    bits.setUnbiasedExponent(maxExponent);
-    bits.setImplicitBit(1);
-    bits.setMantissa(v);
+    bits.set_unbiased_exponent(MAX_EXPONENT);
+    bits.set_implicit_bit(1);
+    bits.set_mantissa(v);
     return bits;
   }
 };
 
 static_assert(
     sizeof(FPBits<long double>) == sizeof(long double),
     "Internal long double representation does not match the machine format.");
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H

libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h

 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 static inline long double nextafter(long double from, long double to) {
   using FPBits = FPBits<long double>;
-  FPBits fromBits(from);
-  if (fromBits.isNaN())
+  FPBits from_bits(from);
+  if (from_bits.is_nan())
     return from;
 
-  FPBits toBits(to);
-  if (toBits.isNaN())
+  FPBits to_bits(to);
+  if (to_bits.is_nan())
     return to;
 
   if (from == to)
     return to;
 
   // Convert pseudo subnormal number to normal number.
-  if (fromBits.getImplicitBit() == 1 && fromBits.getUnbiasedExponent() == 0) {
-    fromBits.setUnbiasedExponent(1);
+  if (from_bits.get_implicit_bit() == 1 &&
+      from_bits.get_unbiased_exponent() == 0) {
+    from_bits.set_unbiased_exponent(1);
   }
 
   using UIntType = FPBits::UIntType;
-  constexpr UIntType signVal = (UIntType(1) << 79);
-  constexpr UIntType mantissaMask =
-      (UIntType(1) << MantissaWidth<long double>::value) - 1;
-  UIntType intVal = fromBits.uintval();
+  constexpr UIntType SIGN_VAL = (UIntType(1) << 79);
+  constexpr UIntType MANTISSA_MASK =
+      (UIntType(1) << MantissaWidth<long double>::VALUE) - 1;
+  UIntType int_val = from_bits.uintval();
   if (from < 0.0l) {
     if (from > to) {
-      if (intVal == (signVal + FPBits::maxSubnormal)) {
+      if (int_val == (SIGN_VAL + FPBits::MAX_SUBNORMAL)) {
         // We deal with normal/subnormal boundary separately to avoid
         // dealing with the implicit bit.
-        intVal = signVal + FPBits::minNormal;
-      } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.setMantissa(0);
+        int_val = SIGN_VAL + FPBits::MIN_NORMAL;
+      } else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) {
+        from_bits.set_mantissa(0);
         // Incrementing exponent might overflow the value to infinity,
         // which is what is expected. Since NaNs are handling separately,
         // it will never overflow "beyond" infinity.
-        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() + 1);
-        return fromBits;
+        from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1);
+        return from_bits;
       } else {
-        ++intVal;
+        ++int_val;
       }
     } else {
-      if (intVal == (signVal + FPBits::minNormal)) {
+      if (int_val == (SIGN_VAL + FPBits::MIN_NORMAL)) {
         // We deal with normal/subnormal boundary separately to avoid
         // dealing with the implicit bit.
-        intVal = signVal + FPBits::maxSubnormal;
-      } else if ((intVal & mantissaMask) == 0) {
-        fromBits.setMantissa(mantissaMask);
+        int_val = SIGN_VAL + FPBits::MAX_SUBNORMAL;
+      } else if ((int_val & MANTISSA_MASK) == 0) {
+        from_bits.set_mantissa(MANTISSA_MASK);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() - 1);
-        return fromBits;
+        from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1);
+        return from_bits;
       } else {
-        --intVal;
+        --int_val;
       }
     }
   } else if (from == 0.0l) {
     if (from > to)
-      intVal = signVal + 1;
+      int_val = SIGN_VAL + 1;
     else
-      intVal = 1;
+      int_val = 1;
   } else {
     if (from > to) {
-      if (intVal == FPBits::minNormal) {
-        intVal = FPBits::maxSubnormal;
-      } else if ((intVal & mantissaMask) == 0) {
-        fromBits.setMantissa(mantissaMask);
+      if (int_val == FPBits::MIN_NORMAL) {
+        int_val = FPBits::MAX_SUBNORMAL;
+      } else if ((int_val & MANTISSA_MASK) == 0) {
+        from_bits.set_mantissa(MANTISSA_MASK);
         // from == 0 is handled separately so decrementing the exponent will not
         // lead to underflow.
-        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() - 1);
-        return fromBits;
+        from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() - 1);
+        return from_bits;
       } else {
-        --intVal;
+        --int_val;
       }
     } else {
-      if (intVal == FPBits::maxSubnormal) {
-        intVal = FPBits::minNormal;
-      } else if ((intVal & mantissaMask) == mantissaMask) {
-        fromBits.setMantissa(0);
+      if (int_val == FPBits::MAX_SUBNORMAL) {
+        int_val = FPBits::MIN_NORMAL;
+      } else if ((int_val & MANTISSA_MASK) == MANTISSA_MASK) {
+        from_bits.set_mantissa(0);
         // Incrementing exponent might overflow the value to infinity,
         // which is what is expected. Since NaNs are handling separately,
         // it will never overflow "beyond" infinity.
-        fromBits.setUnbiasedExponent(fromBits.getUnbiasedExponent() + 1);
-        return fromBits;
+        from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1);
+        return from_bits;
       } else {
-        ++intVal;
+        ++int_val;
       }
     }
   }
 
-  return *reinterpret_cast<long double *>(&intVal);
+  return *reinterpret_cast<long double *>(&int_val);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H

libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h

 
 } // namespace internal
 
 // Correctly rounded SQRT with round to nearest, ties to even.
 // Shift-and-add algorithm.
 template <> inline long double sqrt<long double, 0>(long double x) {
   using UIntType = typename FPBits<long double>::UIntType;
   constexpr UIntType One = UIntType(1)
-                           << int(MantissaWidth<long double>::value);
+                           << int(MantissaWidth<long double>::VALUE);
 
   FPBits<long double> bits(x);
 
-  if (bits.isInfOrNaN()) {
-    if (bits.getSign() && (bits.getMantissa() == 0)) {
+  if (bits.is_inf_or_nan()) {
+    if (bits.get_sign() && (bits.get_mantissa() == 0)) {
       // sqrt(-Inf) = NaN
-      return FPBits<long double>::buildNaN(One >> 1);
+      return FPBits<long double>::build_nan(One >> 1);
     } else {
       // sqrt(NaN) = NaN
       // sqrt(+Inf) = +Inf
       return x;
     }
-  } else if (bits.isZero()) {
+  } else if (bits.is_zero()) {
     // sqrt(+0) = +0
     // sqrt(-0) = -0
     return x;
-  } else if (bits.getSign()) {
+  } else if (bits.get_sign()) {
     // sqrt( negative numbers ) = NaN
-    return FPBits<long double>::buildNaN(One >> 1);
+    return FPBits<long double>::build_nan(One >> 1);
   } else {
-    int xExp = bits.getExponent();
-    UIntType xMant = bits.getMantissa();
+    int xExp = bits.get_exponent();
+    UIntType xMant = bits.get_mantissa();
 
     // Step 1a: Normalize denormal input
     if (bits.getImplicitBit()) {
       xMant |= One;
-    } else if (bits.getUnbiasedExponent() == 0) {
+    } else if (bits.get_unbiased_exponent() == 0) {
       internal::normalize<long double>(xExp, xMant);
     }
 
     // Step 1b: Make sure the exponent is even.
     if (xExp & 1) {
       --xExp;
       xMant <<= 1;
     }
if (bits.is_inf_or_nan()) {
     r <<= 2;
     UIntType tmp = (y << 2) + 1;
     if (r >= tmp) {
       r -= tmp;
       rb = true;
     }
 
     // Append the exponent field.
-    xExp = ((xExp >> 1) + FPBits<long double>::exponentBias);
+    xExp = ((xExp >> 1) + FPBits<long double>::EXPONENT_BIAS);
     y |= (static_cast<UIntType>(xExp)
-          << (MantissaWidth<long double>::value + 1));
+          << (MantissaWidth<long double>::VALUE + 1));
 
     // Round to nearest, ties to even
     if (rb && (lsb || (r != 0))) {
       ++y;
     }
 
     // Extract output
     FPBits<long double> out(0.0L);
-    out.setUnbiasedExponent(xExp);
+    out.set_unbiased_exponent(xExp);
     out.setImplicitBit(1);
-    out.setMantissa((y & (One - 1)));
+    out.set_mantissa((y & (One - 1)));
 
     return out;
   }
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_LONG_DOUBLE_H

libc/src/__support/detailed_powers_of_ten.h

 // -348 to 347. The exponents are implied by a linear expression with slope
 // 217706.0/65536.0 ≈ log(10)/log(2). This is used by the Eisel-Lemire algorithm
 // in str_to_float.h.
 
 constexpr int32_t DETAILED_POWERS_OF_TEN_MIN_EXP_10 = -348;
 constexpr int32_t DETAILED_POWERS_OF_TEN_MAX_EXP_10 = 347;
 
 // This rescales the base 10 exponent by a factor of log(10)/log(2).
-static inline int64_t exp10ToExp2(int64_t exp10) {
+static inline int64_t exp10_to_exp2(int64_t exp10) {
   return (217706 * exp10) >> 16;
 }
 
-static const uint64_t DETAILED_POWERS_OF_TEN[696][2] = {
+static constexpr uint64_t DETAILED_POWERS_OF_TEN[696][2] = {
     {0x1732C869CD60E453, 0xFA8FD5A0081C0288}, // 1e-348
     {0x0E7FBD42205C8EB4, 0x9C99E58405118195}, // 1e-347
     {0x521FAC92A873B261, 0xC3C05EE50655E1FA}, // 1e-346
     {0xE6A797B752909EF9, 0xF4B0769E47EB5A78}, // 1e-345
     {0x9028BED2939A635C, 0x98EE4A22ECF3188B}, // 1e-344
     {0x7432EE873880FC33, 0xBF29DCABA82FDEAE}, // 1e-343
     {0x113FAA2906A13B3F, 0xEEF453D6923BD65A}, // 1e-342
     {0x4AC7CA59A424C507, 0x9558B4661B6565F8}, // 1e-341

libc/src/__support/endian.h

 
 // Converts uint8_t, uint16_t, uint32_t, uint64_t to its big or little endian
 // counterpart.
 // We use explicit template specialization:
 // - to prevent accidental integer promotion.
 // - to prevent fallback in (unlikely) case of middle-endianness.
 
 template <unsigned ORDER> struct Endian {
-  static constexpr const bool isLittle = ORDER == __ORDER_LITTLE_ENDIAN__;
-  static constexpr const bool isBig = ORDER == __ORDER_BIG_ENDIAN__;
-  template <typename T> static T ToBigEndian(T value);
-  template <typename T> static T ToLittleEndian(T value);
+  static constexpr const bool IS_LITTLE = ORDER == __ORDER_LITTLE_ENDIAN__;
+  static constexpr const bool IS_BIG = ORDER == __ORDER_BIG_ENDIAN__;
+  template <typename T> static T to_big_endian(T value);
+  template <typename T> static T to_little_endian(T value);
 };
 
 // Little Endian specializations
 template <>
 template <>
 inline uint8_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToBigEndian<uint8_t>(uint8_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
 inline uint8_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToLittleEndian<uint8_t>(uint8_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
 inline uint16_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToBigEndian<uint16_t>(uint16_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint16_t>(uint16_t v) {
   return __builtin_bswap16(v);
 }
 template <>
 template <>
 inline uint16_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToLittleEndian<uint16_t>(uint16_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint16_t>(uint16_t v) {
   return v;
 }
 template <>
 template <>
 inline uint32_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToBigEndian<uint32_t>(uint32_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint32_t>(uint32_t v) {
   return __builtin_bswap32(v);
 }
 template <>
 template <>
 inline uint32_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToLittleEndian<uint32_t>(uint32_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint32_t>(uint32_t v) {
   return v;
 }
 template <>
 template <>
 inline uint64_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToBigEndian<uint64_t>(uint64_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint64_t>(uint64_t v) {
   return __builtin_bswap64(v);
 }
 template <>
 template <>
 inline uint64_t
-Endian<__ORDER_LITTLE_ENDIAN__>::ToLittleEndian<uint64_t>(uint64_t v) {
+Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint64_t>(uint64_t v) {
   return v;
 }
 
 // Big Endian specializations
 template <>
 template <>
-inline uint8_t Endian<__ORDER_BIG_ENDIAN__>::ToBigEndian<uint8_t>(uint8_t v) {
+inline uint8_t Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
 inline uint8_t
-Endian<__ORDER_BIG_ENDIAN__>::ToLittleEndian<uint8_t>(uint8_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
 inline uint16_t
-Endian<__ORDER_BIG_ENDIAN__>::ToBigEndian<uint16_t>(uint16_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint16_t>(uint16_t v) {
   return v;
 }
 template <>
 template <>
 inline uint16_t
-Endian<__ORDER_BIG_ENDIAN__>::ToLittleEndian<uint16_t>(uint16_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint16_t>(uint16_t v) {
   return __builtin_bswap16(v);
 }
 template <>
 template <>
 inline uint32_t
-Endian<__ORDER_BIG_ENDIAN__>::ToBigEndian<uint32_t>(uint32_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint32_t>(uint32_t v) {
   return v;
 }
 template <>
 template <>
 inline uint32_t
-Endian<__ORDER_BIG_ENDIAN__>::ToLittleEndian<uint32_t>(uint32_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint32_t>(uint32_t v) {
   return __builtin_bswap32(v);
 }
 template <>
 template <>
 inline uint64_t
-Endian<__ORDER_BIG_ENDIAN__>::ToBigEndian<uint64_t>(uint64_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint64_t>(uint64_t v) {
   return v;
 }
 template <>
 template <>
 inline uint64_t
-Endian<__ORDER_BIG_ENDIAN__>::ToLittleEndian<uint64_t>(uint64_t v) {
+Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint64_t>(uint64_t v) {
   return __builtin_bswap64(v);
 }
 
 } // namespace internal
 
 using Endian = internal::Endian<__BYTE_ORDER__>;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ENDIAN_H

libc/src/__support/high_precision_decimal.h

 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_integer.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 struct LShiftTableEntry {
-  uint32_t newDigits;
-  char const *powerOfFive;
+  uint32_t new_digits;
+  char const *power_of_five;
 };
 
 // This is based on the HPD data structure described as part of the Simple
 // Decimal Conversion algorithm by Nigel Tao, described at this link:
 // https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
 class HighPrecisionDecimal {
 
   // This precomputed table speeds up left shifts by having the number of new
class HighPrecisionDecimal {
   // accumulator, minus the number of bits needed to represent the base (in this
   // case 4).
   static constexpr uint32_t MAX_SHIFT_AMOUNT = sizeof(uint64_t) - 4;
 
   // 800 is an arbitrary number of digits, but should be
   // large enough for any practical number.
   static constexpr uint32_t MAX_NUM_DIGITS = 800;
 
-  uint32_t numDigits = 0;
-  int32_t decimalPoint = 0;
+  uint32_t num_digits = 0;
+  int32_t decimal_point = 0;
   bool truncated = false;
   uint8_t digits[MAX_NUM_DIGITS];
 
 private:
-  bool shouldRoundUp(uint32_t roundToDigit) {
-    if (roundToDigit < 0 || roundToDigit >= this->numDigits) {
+  bool should_round_up(uint32_t roundToDigit) {
+    if (roundToDigit < 0 || roundToDigit >= this->num_digits) {
       return false;
     }
 
     // If we're right in the middle and there are no extra digits
     if (this->digits[roundToDigit] == 5 &&
-        roundToDigit + 1 == this->numDigits) {
+        roundToDigit + 1 == this->num_digits) {
 
       // Round up if we've truncated (since that means the result is slightly
       // higher than what's represented.)
       if (this->truncated) {
         return true;
       }
 
       // If this exactly halfway, round to even.
       return this->digits[roundToDigit - 1] % 2 != 0;
     }
     // If there are digits after roundToDigit, they must be non-zero since we
     // trim trailing zeroes after all operations that change digits.
     return this->digits[roundToDigit] >= 5;
   }
 
   // Takes an amount to left shift and returns the number of new digits needed
   // to store the result based on LEFT_SHIFT_DIGIT_TABLE.
-  uint32_t getNumNewDigits(uint32_t lShiftAmount) {
-    const char *powerOfFive = LEFT_SHIFT_DIGIT_TABLE[lShiftAmount].powerOfFive;
-    uint32_t newDigits = LEFT_SHIFT_DIGIT_TABLE[lShiftAmount].newDigits;
-    uint32_t digitIndex = 0;
-    while (powerOfFive[digitIndex] != 0) {
-      if (digitIndex >= this->numDigits) {
-        return newDigits - 1;
-      }
-      if (this->digits[digitIndex] != powerOfFive[digitIndex] - '0') {
-        return newDigits -
-               ((this->digits[digitIndex] < powerOfFive[digitIndex] - '0') ? 1
-                                                                           : 0);
+  uint32_t get_num_new_digits(uint32_t lShiftAmount) {
+    const char *power_of_five =
+        LEFT_SHIFT_DIGIT_TABLE[lShiftAmount].power_of_five;
+    uint32_t new_digits = LEFT_SHIFT_DIGIT_TABLE[lShiftAmount].new_digits;
+    uint32_t digit_index = 0;
+    while (power_of_five[digit_index] != 0) {
+      if (digit_index >= this->num_digits) {
+        return new_digits - 1;
+      }
+      if (this->digits[digit_index] != power_of_five[digit_index] - '0') {
+        return new_digits -
+               ((this->digits[digit_index] < power_of_five[digit_index] - '0')
+                    ? 1
       }
-      ++digitIndex;
+      ++digit_index;
     }
-    return newDigits;
+    return new_digits;
   }
 
   // Trim all trailing 0s
-  void trimTrailingZeroes() {
-    while (this->numDigits > 0 && this->digits[this->numDigits - 1] == 0) {
-      --this->numDigits;
+  void trim_trailing_zeroes() {
+    while (this->num_digits > 0 && this->digits[this->num_digits - 1] == 0) {
+      --this->num_digits;
     }
-    if (this->numDigits == 0) {
-      this->decimalPoint = 0;
+    if (this->num_digits == 0) {
+      this->decimal_point = 0;
     }
   }
 
   // Perform a digitwise binary non-rounding right shift on this value by
   // shiftAmount. The shiftAmount can't be more than MAX_SHIFT_AMOUNT to prevent
   // overflow.
-  void rightShift(uint32_t shiftAmount) {
-    uint32_t readIndex = 0;
-    uint32_t writeIndex = 0;
+  void right_shift(uint32_t shiftAmount) {
+    uint32_t read_index = 0;
+    uint32_t write_index = 0;
 
     uint64_t accumulator = 0;
 
-    const uint64_t shiftMask = (uint64_t(1) << shiftAmount) - 1;
+    const uint64_t shift_mask = (uint64_t(1) << shiftAmount) - 1;
 
     // Warm Up phase: we don't have enough digits to start writing, so just
     // read them into the accumulator.
     while (accumulator >> shiftAmount == 0) {
-      uint64_t readDigit = 0;
+      uint64_t read_digit = 0;
       // If there are still digits to read, read the next one, else the digit is
       // assumed to be 0.
-      if (readIndex < this->numDigits) {
-        readDigit = this->digits[readIndex];
+      if (read_index < this->num_digits) {
+        read_digit = this->digits[read_index];
       }
-      accumulator = accumulator * 10 + readDigit;
-      ++readIndex;
+      accumulator = accumulator * 10 + read_digit;
+      ++read_index;
     }
 
     // Shift the decimal point by the number of digits it took to fill the
     // accumulator.
-    this->decimalPoint -= readIndex - 1;
+    this->decimal_point -= read_index - 1;
 
     // Middle phase: we have enough digits to write, as well as more digits to
     // read. Keep reading until we run out of digits.
-    while (readIndex < this->numDigits) {
-      uint64_t readDigit = this->digits[readIndex];
-      uint64_t writeDigit = accumulator >> shiftAmount;
-      accumulator &= shiftMask;
-      this->digits[writeIndex] = static_cast<uint8_t>(writeDigit);
-      accumulator = accumulator * 10 + readDigit;
-      ++readIndex;
-      ++writeIndex;
+    while (read_index < this->num_digits) {
+      uint64_t read_digit = this->digits[read_index];
+      uint64_t write_digit = accumulator >> shiftAmount;
+      accumulator &= shift_mask;
+      this->digits[write_index] = static_cast<uint8_t>(write_digit);
+      accumulator = accumulator * 10 + read_digit;
+      ++read_index;
+      ++write_index;
     }
 
     // Cool Down phase: All of the readable digits have been read, so just write
     // the remainder, while treating any more digits as 0.
     while (accumulator > 0) {
-      uint64_t writeDigit = accumulator >> shiftAmount;
-      accumulator &= shiftMask;
-      if (writeIndex < MAX_NUM_DIGITS) {
-        this->digits[writeIndex] = static_cast<uint8_t>(writeDigit);
-        ++writeIndex;
-      } else if (writeDigit > 0) {
+      uint64_t write_digit = accumulator >> shiftAmount;
+      accumulator &= shift_mask;
+      if (write_index < MAX_NUM_DIGITS) {
+        this->digits[write_index] = static_cast<uint8_t>(write_digit);
+        ++write_index;
+      } else if (write_digit > 0) {
         this->truncated = true;
       }
       accumulator = accumulator * 10;
     }
-    this->numDigits = writeIndex;
-    this->trimTrailingZeroes();
+    this->num_digits = write_index;
+    this->trim_trailing_zeroes();
   }
 
   // Perform a digitwise binary non-rounding left shift on this value by
   // shiftAmount. The shiftAmount can't be more than MAX_SHIFT_AMOUNT to prevent
   // overflow.
-  void leftShift(uint32_t shiftAmount) {
-    uint32_t newDigits = this->getNumNewDigits(shiftAmount);
+  void left_shift(uint32_t shiftAmount) {
+    uint32_t new_digits = this->get_num_new_digits(shiftAmount);
 
-    int32_t readIndex = this->numDigits - 1;
-    uint32_t writeIndex = this->numDigits + newDigits;
+    int32_t read_index = this->num_digits - 1;
+    uint32_t write_index = this->num_digits + new_digits;
 
     uint64_t accumulator = 0;
 
     // No Warm Up phase. Since we're putting digits in at the top and taking
     // digits from the bottom we don't have to wait for the accumulator to fill.
 
     // Middle phase: while we have more digits to read, keep reading as well as
     // writing.
-    while (readIndex >= 0) {
-      accumulator += static_cast<uint64_t>(this->digits[readIndex])
+    while (read_index >= 0) {
+      accumulator += static_cast<uint64_t>(this->digits[read_index])
                      << shiftAmount;
-      uint64_t nextAccumulator = accumulator / 10;
-      uint64_t writeDigit = accumulator - (10 * nextAccumulator);
-      --writeIndex;
-      if (writeIndex < MAX_NUM_DIGITS) {
-        this->digits[writeIndex] = static_cast<uint8_t>(writeDigit);
-      } else if (writeDigit != 0) {
+      uint64_t next_accumulator = accumulator / 10;
+      uint64_t write_digit = accumulator - (10 * next_accumulator);
+      --write_index;
+      if (write_index < MAX_NUM_DIGITS) {
+        this->digits[write_index] = static_cast<uint8_t>(write_digit);
+      } else if (write_digit != 0) {
         this->truncated = true;
       }
-      accumulator = nextAccumulator;
-      --readIndex;
+      accumulator = next_accumulator;
+      --read_index;
     }
 
     // Cool Down phase: there are no more digits to read, so just write the
     // remaining digits in the accumulator.
     while (accumulator > 0) {
-      uint64_t nextAccumulator = accumulator / 10;
-      uint64_t writeDigit = accumulator - (10 * nextAccumulator);
-      --writeIndex;
-      if (writeIndex < MAX_NUM_DIGITS) {
-        this->digits[writeIndex] = static_cast<uint8_t>(writeDigit);
-      } else if (writeDigit != 0) {
+      uint64_t next_accumulator = accumulator / 10;
+      uint64_t write_digit = accumulator - (10 * next_accumulator);
+      --write_index;
+      if (write_index < MAX_NUM_DIGITS) {
+        this->digits[write_index] = static_cast<uint8_t>(write_digit);
+      } else if (write_digit != 0) {
         this->truncated = true;
       }
-      accumulator = nextAccumulator;
+      accumulator = next_accumulator;
     }
 
-    this->numDigits += newDigits;
-    if (this->numDigits > MAX_NUM_DIGITS) {
-      this->numDigits = MAX_NUM_DIGITS;
+    this->num_digits += new_digits;
+    if (this->num_digits > MAX_NUM_DIGITS) {
+      this->num_digits = MAX_NUM_DIGITS;
     }
-    this->decimalPoint += newDigits;
-    this->trimTrailingZeroes();
+    this->decimal_point += new_digits;
+    this->trim_trailing_zeroes();
   }
 
 public:
   // numString is assumed to be a string of numeric characters. It doesn't
   // handle leading spaces.
   HighPrecisionDecimal(const char *__restrict numString) {
-    bool sawDot = false;
+    bool saw_dot = false;
     while (isdigit(*numString) || *numString == '.') {
       if (*numString == '.') {
-        if (sawDot) {
+        if (saw_dot) {
           break;
         }
-        this->decimalPoint = this->numDigits;
-        sawDot = true;
+        this->decimal_point = this->num_digits;
+        saw_dot = true;
       } else {
-        if (*numString == '0' && this->numDigits == 0) {
-          --this->decimalPoint;
+        if (*numString == '0' && this->num_digits == 0) {
+          --this->decimal_point;
           ++numString;
           continue;
         }
-        if (this->numDigits < MAX_NUM_DIGITS) {
-          this->digits[this->numDigits] = *numString - '0';
-          ++this->numDigits;
+        if (this->num_digits < MAX_NUM_DIGITS) {
+          this->digits[this->num_digits] = *numString - '0';
+          ++this->num_digits;
         } else if (*numString != '0') {
           this->truncated = true;
         }
       }
       ++numString;
     }
 
-    if (!sawDot) {
-      this->decimalPoint = this->numDigits;
+    if (!saw_dot) {
+      this->decimal_point = this->num_digits;
     }
 
     if ((*numString | 32) == 'e') {
       ++numString;
       if (isdigit(*numString) || *numString == '+' || *numString == '-') {
-        int32_t addToExp = strtointeger<int32_t>(numString, nullptr, 10);
-        if (addToExp > 100000) {
-          addToExp = 100000;
-        } else if (addToExp < -100000) {
-          addToExp = -100000;
+        int32_t add_to_exp = strtointeger<int32_t>(numString, nullptr, 10);
+        if (add_to_exp > 100000) {
+          add_to_exp = 100000;
+        } else if (add_to_exp < -100000) {
+          add_to_exp = -100000;
         }
-        this->decimalPoint += addToExp;
+        this->decimal_point += add_to_exp;
       }
     }
 
-    this->trimTrailingZeroes();
+    this->trim_trailing_zeroes();
   }
 
   // Binary shift left (shiftAmount > 0) or right (shiftAmount < 0)
   void shift(int shiftAmount) {
     if (shiftAmount == 0) {
       return;
     }
     // Left
     else if (shiftAmount > 0) {
       while (static_cast<uint32_t>(shiftAmount) > MAX_SHIFT_AMOUNT) {
-        this->leftShift(MAX_SHIFT_AMOUNT);
+        this->left_shift(MAX_SHIFT_AMOUNT);
         shiftAmount -= MAX_SHIFT_AMOUNT;
       }
-      this->leftShift(shiftAmount);
+      this->left_shift(shiftAmount);
     }
     // Right
     else {
       while (static_cast<uint32_t>(shiftAmount) < -MAX_SHIFT_AMOUNT) {
-        this->rightShift(MAX_SHIFT_AMOUNT);
+        this->right_shift(MAX_SHIFT_AMOUNT);
         shiftAmount += MAX_SHIFT_AMOUNT;
       }
-      this->rightShift(-shiftAmount);
+      this->right_shift(-shiftAmount);
     }
   }
 
   // Round the number represented to the closest value of unsigned int type T.
   // This is done ignoring overflow.
-  template <class T> T roundToIntegerType() {
+  template <class T> T round_to_integer_type() {
     T result = 0;
-    uint32_t curDigit = 0;
+    uint32_t cur_digit = 0;
 
-    while (static_cast<int32_t>(curDigit) < this->decimalPoint &&
-           curDigit < this->numDigits) {
-      result = result * 10 + (this->digits[curDigit]);
-      ++curDigit;
+    while (static_cast<int32_t>(cur_digit) < this->decimal_point &&
+           cur_digit < this->num_digits) {
+      result = result * 10 + (this->digits[cur_digit]);
+      ++cur_digit;
     }
 
     // If there are implicit 0s at the end of the number, include those.
-    while (static_cast<int32_t>(curDigit) < this->decimalPoint) {
+    while (static_cast<int32_t>(cur_digit) < this->decimal_point) {
       result *= 10;
-      ++curDigit;
+      ++cur_digit;
     }
-    if (this->shouldRoundUp(this->decimalPoint)) {
+    if (this->should_round_up(this->decimal_point)) {
       ++result;
     }
     return result;
   }
 
   // Extra functions for testing.
 
-  uint8_t *getDigits() { return this->digits; }
-  uint32_t getNumDigits() { return this->numDigits; }
-  int32_t getDecimalPoint() { return this->decimalPoint; }
-  void setTruncated(bool trunc) { this->truncated = trunc; }
+  uint8_t *get_digits() { return this->digits; }
+  uint32_t get_num_digits() { return this->num_digits; }
+  int32_t get_decimal_point() { return this->decimal_point; }
+  void set_truncated(bool trunc) { this->truncated = trunc; }
 };
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_SUPPORT_HIGH_PRECISION_DECIMAL_H

libc/src/__support/integer_operations.h

 #define LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H
 
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 
 template <typename T>
 static constexpr cpp::EnableIfType<cpp::IsIntegral<T>::Value, T>
-integerAbs(T n) {
+integer_abs(T n) {
   return (n < 0) ? -n : n;
 }
 
 template <typename T>
 static constexpr cpp::EnableIfType<cpp::IsIntegral<T>::Value, void>
-integerRemQuo(T x, T y, T &quot, T &rem) {
+integer_rem_quo(T x, T y, T &quot, T &rem) {
   quot = x / y;
   rem = x % y;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDLIB_ABS_UTILS_H

libc/src/__support/str_to_float.h

 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include <errno.h>
 
 namespace __llvm_libc {
 namespace internal {
 
-template <class T> uint32_t inline leadingZeroes(T inputNumber) {
+template <class T> uint32_t inline leading_zeroes(T inputNumber) {
   // TODO(michaelrj): investigate the portability of using something like
   // __builtin_clz for specific types.
-  constexpr uint32_t bitsInT = sizeof(T) * 8;
+  constexpr uint32_t BITS_IN_T = sizeof(T) * 8;
   if (inputNumber == 0) {
-    return bitsInT;
+    return BITS_IN_T;
   }
-  uint32_t curGuess = bitsInT / 2;
-  uint32_t rangeSize = bitsInT / 2;
+  uint32_t cur_guess = BITS_IN_T / 2;
+  uint32_t range_size = BITS_IN_T / 2;
   // while either shifting by curGuess does not get rid of all of the bits or
   // shifting by one less also gets rid of all of the bits then we have not
   // found the first bit.
-  while (((inputNumber >> curGuess) > 0) ||
-         ((inputNumber >> (curGuess - 1)) == 0)) {
+  while (((inputNumber >> cur_guess) > 0) ||
+         ((inputNumber >> (cur_guess - 1)) == 0)) {
     // Binary search for the first set bit
-    rangeSize /= 2;
-    if (rangeSize == 0) {
+    range_size /= 2;
+    if (range_size == 0) {
       break;
     }
-    if ((inputNumber >> curGuess) > 0) {
-      curGuess += rangeSize;
+    if ((inputNumber >> cur_guess) > 0) {
+      cur_guess += range_size;
     } else {
-      curGuess -= rangeSize;
+      cur_guess -= range_size;
     }
   }
-  if (inputNumber >> curGuess > 0) {
-    curGuess++;
+  if (inputNumber >> cur_guess > 0) {
+    cur_guess++;
   }
-  return bitsInT - curGuess;
+  return BITS_IN_T - cur_guess;
 }
 
-template <> uint32_t inline leadingZeroes<uint32_t>(uint32_t inputNumber) {
+template <> uint32_t inline leading_zeroes<uint32_t>(uint32_t inputNumber) {
   return inputNumber == 0 ? 32 : __builtin_clz(inputNumber);
 }
 
-template <> uint32_t inline leadingZeroes<uint64_t>(uint64_t inputNumber) {
+template <> uint32_t inline leading_zeroes<uint64_t>(uint64_t inputNumber) {
   return inputNumber == 0 ? 64 : __builtin_clzll(inputNumber);
 }
 
 static inline uint64_t low64(__uint128_t num) {
   return static_cast<uint64_t>(num & 0xffffffffffffffff);
 }
 
 static inline uint64_t high64(__uint128_t num) {
   return static_cast<uint64_t>(num >> 64);
 }
 
 // This Eisel-Lemire implementation is based on the algorithm described in the
 // paper Number Parsing at a Gigabyte per Second, Software: Practice and
 // Experience 51 (8), 2021 (https://arxiv.org/abs/2101.11408), as well as the
 // description by Nigel Tao
 // (https://nigeltao.github.io/blog/2020/eisel-lemire.html) and the golang
 // implementation, also by Nigel Tao
 // (https://github.com/golang/go/blob/release-branch.go1.16/src/strconv/eisel_lemire.go#L25)
 // for some optimizations as well as handling 32 bit floats.
 template <class T>
 static inline bool
-eiselLemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
+eisel_lemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
              typename fputil::FPBits<T>::UIntType *outputMantissa,
              uint32_t *outputExp2) {
 
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BITS_IN_MANTISSA = sizeof(mantissa) * 8;
 
   if (sizeof(T) > 8) { // This algorithm cannot handle anything longer than a
                        // double, so we skip straight to the fallback.
     return false;
   }
 
   // Exp10 Range
   if (exp10 < DETAILED_POWERS_OF_TEN_MIN_EXP_10 ||
       exp10 > DETAILED_POWERS_OF_TEN_MAX_EXP_10) {
     return false;
   }
 
   // Normalization
-  uint32_t clz = leadingZeroes<BitsType>(mantissa);
+  uint32_t clz = leading_zeroes<BitsType>(mantissa);
   mantissa <<= clz;
 
-  uint32_t exp2 = exp10ToExp2(exp10) + BITS_IN_MANTISSA +
-                  fputil::FloatProperties<T>::exponentBias - clz;
+  uint32_t exp2 = exp10_to_exp2(exp10) + BITS_IN_MANTISSA +
+                  fputil::FloatProperties<T>::EXPONENT_BIAS - clz;
 
   // Multiplication
-  const uint64_t *powerOfTen =
+  const uint64_t *power_of_ten =
       DETAILED_POWERS_OF_TEN[exp10 - DETAILED_POWERS_OF_TEN_MIN_EXP_10];
 
-  __uint128_t firstApprox = static_cast<__uint128_t>(mantissa) *
-                            static_cast<__uint128_t>(powerOfTen[1]);
+  __uint128_t first_approx = static_cast<__uint128_t>(mantissa) *
+                             static_cast<__uint128_t>(power_of_ten[1]);
 
   // Wider Approximation
-  __uint128_t finalApprox;
+  __uint128_t final_approx;
   // The halfway constant is used to check if the bits that will be shifted away
   // intially are all 1. For doubles this is 64 (bitstype size) - 52 (final
   // mantissa size) - 3 (we shift away the last two bits separately for
   // accuracy, and the most significant bit is ignored.) = 9. Similarly, it's 6
   // for floats in this case.
-  const uint64_t halfwayConstant = sizeof(T) == 8 ? 0x1FF : 0x3F;
-  if ((high64(firstApprox) & halfwayConstant) == halfwayConstant &&
-      low64(firstApprox) + mantissa < mantissa) {
-    __uint128_t lowBits = static_cast<__uint128_t>(mantissa) *
-                          static_cast<__uint128_t>(powerOfTen[0]);
-    __uint128_t secondApprox =
-        firstApprox + static_cast<__uint128_t>(high64(lowBits));
-
-    if ((high64(secondApprox) & halfwayConstant) == halfwayConstant &&
-        low64(secondApprox) + 1 == 0 && low64(lowBits) + mantissa < mantissa) {
+  const uint64_t halfway_constant = sizeof(T) == 8 ? 0x1FF : 0x3F;
+  if ((high64(first_approx) & halfway_constant) == halfway_constant &&
+      low64(first_approx) + mantissa < mantissa) {
+    __uint128_t low_bits = static_cast<__uint128_t>(mantissa) *
+                           static_cast<__uint128_t>(power_of_ten[0]);
+    __uint128_t second_approx =
+        first_approx + static_cast<__uint128_t>(high64(low_bits));
+
+    if ((high64(second_approx) & halfway_constant) == halfway_constant &&
+        low64(second_approx) + 1 == 0 &&
+        low64(low_bits) + mantissa < mantissa) {
       return false;
     }
-    finalApprox = secondApprox;
+    final_approx = second_approx;
   } else {
-    finalApprox = firstApprox;
+    final_approx = first_approx;
   }
 
   // Shifting to 54 bits for doubles and 25 bits for floats
-  BitsType msb = high64(finalApprox) >> (BITS_IN_MANTISSA - 1);
-  BitsType finalMantissa =
-      high64(finalApprox) >> (msb + BITS_IN_MANTISSA -
-                              (fputil::FloatProperties<T>::mantissaWidth + 3));
+  BitsType msb = high64(final_approx) >> (BITS_IN_MANTISSA - 1);
+  BitsType final_mantissa = high64(final_approx) >>
+                            (msb + BITS_IN_MANTISSA -
+                             (fputil::FloatProperties<T>::MANTISSA_WIDTH + 3));
   exp2 -= 1 ^ msb; // same as !msb
 
   // Half-way ambiguity
-  if (low64(finalApprox) == 0 && (high64(finalApprox) & halfwayConstant) == 0 &&
-      (finalMantissa & 3) == 1) {
+  if (low64(final_approx) == 0 &&
+      (high64(final_approx) & halfway_constant) == 0 &&
+      (final_mantissa & 3) == 1) {
     return false;
   }
 
   // From 54 to 53 bits for doubles and 25 to 24 bits for floats
-  finalMantissa += finalMantissa & 1;
-  finalMantissa >>= 1;
-  if ((finalMantissa >> (fputil::FloatProperties<T>::mantissaWidth + 1)) > 0) {
-    finalMantissa >>= 1;
+  final_mantissa += final_mantissa & 1;
+  final_mantissa >>= 1;
+  if ((final_mantissa >> (fputil::FloatProperties<T>::MANTISSA_WIDTH + 1)) >
+      0) {
+    final_mantissa >>= 1;
     ++exp2;
   }
 
   // The if block is equivalent to (but has fewer branches than):
   //   if exp2 <= 0 || exp2 >= 0x7FF { etc }
-  if (exp2 - 1 >= (1 << fputil::FloatProperties<T>::exponentWidth) - 2) {
+  if (exp2 - 1 >= (1 << fputil::FloatProperties<T>::EXPONENT_WIDTH) - 2) {
     return false;
   }
 
-  *outputMantissa = finalMantissa;
+  *outputMantissa = final_mantissa;
   *outputExp2 = exp2;
   return true;
 }
 
 // The nth item in POWERS_OF_TWO represents the greatest power of two less than
 // 10^n. This tells us how much we can safely shift without overshooting.
 constexpr uint8_t POWERS_OF_TWO[19] = {
     0, 3, 6, 9, 13, 16, 19, 23, 26, 29, 33, 36, 39, 43, 46, 49, 53, 56, 59,
 };
 constexpr int32_t NUM_POWERS_OF_TWO =
     sizeof(POWERS_OF_TWO) / sizeof(POWERS_OF_TWO[0]);
 
 // Takes a mantissa and base 10 exponent and converts it into its closest
 // floating point type T equivalent. This is the fallback algorithm used when
 // the Eisel-Lemire algorithm fails, it's slower but more accurate. It's based
 // on the Simple Decimal Conversion algorithm by Nigel Tao, described at this
 // link: https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
 template <class T>
 static inline void
-simpleDecimalConversion(const char *__restrict numStart,
+simple_decimal_conversion(const char *__restrict numStart,
                           typename fputil::FPBits<T>::UIntType *outputMantissa,
                           uint32_t *outputExp2) {
 
   int32_t exp2 = 0;
   HighPrecisionDecimal hpd = HighPrecisionDecimal(numStart);
 
-  if (hpd.getNumDigits() == 0) {
+  if (hpd.get_num_digits() == 0) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     return;
   }
 
   // If the exponent is too large and can't be represented in this size of
   // float, return inf.
-  if (hpd.getDecimalPoint() > 0 &&
-      exp10ToExp2(hpd.getDecimalPoint() - 1) >
-          static_cast<int64_t>(fputil::FloatProperties<T>::exponentBias)) {
+  if (hpd.get_decimal_point() > 0 &&
+      exp10_to_exp2(hpd.get_decimal_point() - 1) >
+          static_cast<int64_t>(fputil::FloatProperties<T>::EXPONENT_BIAS)) {
     *outputMantissa = 0;
-    *outputExp2 = fputil::FPBits<T>::maxExponent;
+    *outputExp2 = fputil::FPBits<T>::MAX_EXPONENT;
     errno = ERANGE;
     return;
   }
   // If the exponent is too small even for a subnormal, return 0.
-  if (hpd.getDecimalPoint() < 0 &&
-      exp10ToExp2(-hpd.getDecimalPoint()) >
-          static_cast<int64_t>(fputil::FloatProperties<T>::exponentBias +
-                               fputil::FloatProperties<T>::mantissaWidth)) {
+  if (hpd.get_decimal_point() < 0 &&
+      exp10_to_exp2(-hpd.get_decimal_point()) >
+          static_cast<int64_t>(fputil::FloatProperties<T>::EXPONENT_BIAS +
+                               fputil::FloatProperties<T>::MANTISSA_WIDTH)) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     errno = ERANGE;
     return;
   }
 
   // Right shift until the number is smaller than 1.
-  while (hpd.getDecimalPoint() > 0) {
-    int32_t shiftAmount = 0;
-    if (hpd.getDecimalPoint() >= NUM_POWERS_OF_TWO) {
-      shiftAmount = 60;
+  while (hpd.get_decimal_point() > 0) {
+    int32_t shift_amount = 0;
+    if (hpd.get_decimal_point() >= NUM_POWERS_OF_TWO) {
+      shift_amount = 60;
     } else {
-      shiftAmount = POWERS_OF_TWO[hpd.getDecimalPoint()];
+      shift_amount = POWERS_OF_TWO[hpd.get_decimal_point()];
     }
-    exp2 += shiftAmount;
-    hpd.shift(-shiftAmount);
+    exp2 += shift_amount;
+    hpd.shift(-shift_amount);
   }
 
   // Left shift until the number is between 1/2 and 1
-  while (hpd.getDecimalPoint() < 0 ||
-         (hpd.getDecimalPoint() == 0 && hpd.getDigits()[0] < 5)) {
-    int32_t shiftAmount = 0;
-
-    if (-hpd.getDecimalPoint() >= NUM_POWERS_OF_TWO) {
-      shiftAmount = 60;
-    } else if (hpd.getDecimalPoint() != 0) {
-      shiftAmount = POWERS_OF_TWO[-hpd.getDecimalPoint()];
+  while (hpd.get_decimal_point() < 0 ||
+         (hpd.get_decimal_point() == 0 && hpd.get_digits()[0] < 5)) {
+    int32_t shift_amount = 0;
+
+    if (-hpd.get_decimal_point() >= NUM_POWERS_OF_TWO) {
+      shift_amount = 60;
+    } else if (hpd.get_decimal_point() != 0) {
+      shift_amount = POWERS_OF_TWO[-hpd.get_decimal_point()];
     } else { // This handles the case of the number being between .1 and .5
-      shiftAmount = 1;
+      shift_amount = 1;
     }
-    exp2 -= shiftAmount;
-    hpd.shift(shiftAmount);
+    exp2 -= shift_amount;
+    hpd.shift(shift_amount);
   }
 
   // Left shift once so that the number is between 1 and 2
   --exp2;
   hpd.shift(1);
 
   // Get the biased exponent
-  exp2 += fputil::FloatProperties<T>::exponentBias;
+  exp2 += fputil::FloatProperties<T>::EXPONENT_BIAS;
 
   // Handle the exponent being too large (and return inf).
-  if (exp2 >= fputil::FPBits<T>::maxExponent) {
+  if (exp2 >= fputil::FPBits<T>::MAX_EXPONENT) {
     *outputMantissa = 0;
-    *outputExp2 = fputil::FPBits<T>::maxExponent;
+    *outputExp2 = fputil::FPBits<T>::MAX_EXPONENT;
     errno = ERANGE;
     return;
   }
 
   // Shift left to fill the mantissa
-  hpd.shift(fputil::FloatProperties<T>::mantissaWidth);
-  typename fputil::FPBits<T>::UIntType finalMantissa =
-      hpd.roundToIntegerType<typename fputil::FPBits<T>::UIntType>();
+  hpd.shift(fputil::FloatProperties<T>::MANTISSA_WIDTH);
+  typename fputil::FPBits<T>::UIntType final_mantissa =
+      hpd.round_to_integer_type<typename fputil::FPBits<T>::UIntType>();
 
   // Handle subnormals
   if (exp2 <= 0) {
     // Shift right until there is a valid exponent
     while (exp2 < 0) {
       hpd.shift(-1);
       ++exp2;
     }
     // Shift right one more time to compensate for the left shift to get it
     // between 1 and 2.
     hpd.shift(-1);
-    finalMantissa =
-        hpd.roundToIntegerType<typename fputil::FPBits<T>::UIntType>();
+    final_mantissa =
+        hpd.round_to_integer_type<typename fputil::FPBits<T>::UIntType>();
 
     // Check if by shifting right we've caused this to round to a normal number.
-    if ((finalMantissa >> fputil::FloatProperties<T>::mantissaWidth) != 0) {
+    if ((final_mantissa >> fputil::FloatProperties<T>::MANTISSA_WIDTH) != 0) {
       ++exp2;
     }
   }
 
   // Check if rounding added a bit, and shift down if that's the case.
-  if (finalMantissa == typename fputil::FPBits<T>::UIntType(2)
-                           << fputil::FloatProperties<T>::mantissaWidth) {
-    finalMantissa >>= 1;
+  if (final_mantissa == typename fputil::FPBits<T>::UIntType(2)
+                            << fputil::FloatProperties<T>::MANTISSA_WIDTH) {
+    final_mantissa >>= 1;
     ++exp2;
   }
 
   if (exp2 == 0) {
     errno = ERANGE;
   }
 
-  *outputMantissa = finalMantissa;
+  *outputMantissa = final_mantissa;
   *outputExp2 = exp2;
 }
 
 // This class is used for templating the constants for Clinger's Fast Path,
 // described as a method of approximation in
 // Clinger WD. How to Read Floating Point Numbers Accurately. SIGPLAN Not 1990
 // Jun;25(6):92–101. https://doi.org/10.1145/93548.93557.
 // As well as the additions by Gay that extend the useful range by the number of
 // exact digits stored by the float type, described in
 // Gay DM, Correctly rounded binary-decimal and decimal-binary conversions;
 // 1990. AT&T Bell Laboratories Numerical Analysis Manuscript 90-10.
 template <class T> class ClingerConsts;
 
 template <> class ClingerConsts<float> {
 public:
-  static constexpr float powersOfTenArray[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
+  static constexpr float POWERS_OF_TEN_ARRAY[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
                                                   1e6, 1e7, 1e8, 1e9, 1e10};
-  static constexpr int32_t exactPowersOfTen = 10;
-  static constexpr int32_t digitsInMantissa = 7;
-  static constexpr float maxExactInt = 16777215.0;
+  static constexpr int32_t EXACT_POWERS_OF_TEN = 10;
+  static constexpr int32_t DIGITS_IN_MANTISSA = 7;
+  static constexpr float MAX_EXACT_INT = 16777215.0;
 };
 
 template <> class ClingerConsts<double> {
 public:
-  static constexpr double powersOfTenArray[] = {
+  static constexpr double POWERS_OF_TEN_ARRAY[] = {
       1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
       1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-  static constexpr int32_t exactPowersOfTen = 22;
-  static constexpr int32_t digitsInMantissa = 15;
-  static constexpr double maxExactInt = 9007199254740991.0;
+  static constexpr int32_t EXACT_POWERS_OF_TEN = 22;
+  static constexpr int32_t DIGITS_IN_MANTISSA = 15;
+  static constexpr double MAX_EXACT_INT = 9007199254740991.0;
 };
 
 // Take an exact mantissa and exponent and attempt to convert it using only
 // exact floating point arithmetic. This only handles numbers with low
 // exponents, but handles them quickly. This is an implementation of Clinger's
 // Fast Path, as described above.
 template <class T>
 static inline bool
-clingerFastPath(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
+clinger_fast_path(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
                   typename fputil::FPBits<T>::UIntType *outputMantissa,
                   uint32_t *outputExp2) {
-  if (mantissa >> fputil::FloatProperties<T>::mantissaWidth > 0) {
+  if (mantissa >> fputil::FloatProperties<T>::MANTISSA_WIDTH > 0) {
     return false;
   }
 
   fputil::FPBits<T> result;
-  T floatMantissa = static_cast<T>(mantissa);
+  T float_mantissa = static_cast<T>(mantissa);
 
   if (exp10 == 0) {
-    result = fputil::FPBits<T>(floatMantissa);
+    result = fputil::FPBits<T>(float_mantissa);
   }
   if (exp10 > 0) {
-    if (exp10 > ClingerConsts<T>::exactPowersOfTen +
-                    ClingerConsts<T>::digitsInMantissa) {
+    if (exp10 > ClingerConsts<T>::EXACT_POWERS_OF_TEN +
+                    ClingerConsts<T>::DIGITS_IN_MANTISSA) {
       return false;
     }
-    if (exp10 > ClingerConsts<T>::exactPowersOfTen) {
-      floatMantissa =
-          floatMantissa *
-          ClingerConsts<
-              T>::powersOfTenArray[exp10 - ClingerConsts<T>::exactPowersOfTen];
-      exp10 = ClingerConsts<T>::exactPowersOfTen;
+    if (exp10 > ClingerConsts<T>::EXACT_POWERS_OF_TEN) {
+      float_mantissa = float_mantissa *
+                       ClingerConsts<T>::POWERS_OF_TEN_ARRAY
+                           [exp10 - ClingerConsts<T>::EXACT_POWERS_OF_TEN];
+      exp10 = ClingerConsts<T>::EXACT_POWERS_OF_TEN;
     }
-    if (floatMantissa > ClingerConsts<T>::maxExactInt) {
+    if (float_mantissa > ClingerConsts<T>::MAX_EXACT_INT) {
       return false;
     }
-    result = fputil::FPBits<T>(floatMantissa *
-                               ClingerConsts<T>::powersOfTenArray[exp10]);
+    result = fputil::FPBits<T>(float_mantissa *
+                               ClingerConsts<T>::POWERS_OF_TEN_ARRAY[exp10]);
   } else if (exp10 < 0) {
-    if (-exp10 > ClingerConsts<T>::exactPowersOfTen) {
+    if (-exp10 > ClingerConsts<T>::EXACT_POWERS_OF_TEN) {
       return false;
     }
-    result = fputil::FPBits<T>(floatMantissa /
-                               ClingerConsts<T>::powersOfTenArray[-exp10]);
+    result = fputil::FPBits<T>(float_mantissa /
+                               ClingerConsts<T>::POWERS_OF_TEN_ARRAY[-exp10]);
   }
-  *outputMantissa = result.getMantissa();
-  *outputExp2 = result.getUnbiasedExponent();
+  *outputMantissa = result.get_mantissa();
+  *outputExp2 = result.get_unbiased_exponent();
   return true;
 }
 
 // Takes a mantissa and base 10 exponent and converts it into its closest
 // floating point type T equivalient. First we try the Eisel-Lemire algorithm,
 // then if that fails then we fall back to a more accurate algorithm for
 // accuracy. The resulting mantissa and exponent are placed in outputMantissa
 // and outputExp2.
 template <class T>
 static inline void
-decimalExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
-                  const char *__restrict numStart, bool truncated,
+decimal_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa,
+                     int32_t exp10, const char *__restrict numStart,
+                     bool truncated,
                      typename fputil::FPBits<T>::UIntType *outputMantissa,
                      uint32_t *outputExp2) {
   // If the exponent is too large and can't be represented in this size of
   // float, return inf. These bounds are very loose, but are mostly serving as a
   // first pass. Some close numbers getting through is okay.
   if (exp10 >
-      static_cast<int64_t>(fputil::FloatProperties<T>::exponentBias) / 3) {
+      static_cast<int64_t>(fputil::FloatProperties<T>::EXPONENT_BIAS) / 3) {
     *outputMantissa = 0;
-    *outputExp2 = fputil::FPBits<T>::maxExponent;
+    *outputExp2 = fputil::FPBits<T>::MAX_EXPONENT;
     errno = ERANGE;
     return;
   }
   // If the exponent is too small even for a subnormal, return 0.
   if (exp10 < 0 &&
       -static_cast<int64_t>(exp10) >
-          static_cast<int64_t>(fputil::FloatProperties<T>::exponentBias +
-                               fputil::FloatProperties<T>::mantissaWidth) /
+          static_cast<int64_t>(fputil::FloatProperties<T>::EXPONENT_BIAS +
+                               fputil::FloatProperties<T>::MANTISSA_WIDTH) /
               2) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     errno = ERANGE;
     return;
   }
 
   if (!truncated) {
-    if (clingerFastPath<T>(mantissa, exp10, outputMantissa, outputExp2)) {
+    if (clinger_fast_path<T>(mantissa, exp10, outputMantissa, outputExp2)) {
       return;
     }
   }
 
   // Try Eisel-Lemire
-  if (eiselLemire<T>(mantissa, exp10, outputMantissa, outputExp2)) {
+  if (eisel_lemire<T>(mantissa, exp10, outputMantissa, outputExp2)) {
     if (!truncated) {
       return;
     }
     // If the mantissa is truncated, then the result may be off by the LSB, so
     // check if rounding the mantissa up changes the result. If not, then it's
     // safe, else use the fallback.
-    typename fputil::FPBits<T>::UIntType firstMantissa = *outputMantissa;
-    uint32_t firstExp2 = *outputExp2;
-    if (eiselLemire<T>(mantissa + 1, exp10, outputMantissa, outputExp2)) {
-      if (*outputMantissa == firstMantissa && *outputExp2 == firstExp2) {
+    typename fputil::FPBits<T>::UIntType first_mantissa = *outputMantissa;
+    uint32_t first_exp2 = *outputExp2;
+    if (eisel_lemire<T>(mantissa + 1, exp10, outputMantissa, outputExp2)) {
+      if (*outputMantissa == first_mantissa && *outputExp2 == first_exp2) {
         return;
       }
     }
   }
 
-  simpleDecimalConversion<T>(numStart, outputMantissa, outputExp2);
+  simple_decimal_conversion<T>(numStart, outputMantissa, outputExp2);
 
   return;
 }
 
 // Takes a mantissa and base 2 exponent and converts it into its closest
 // floating point type T equivalient. Since the exponent is already in the right
 // form, this is mostly just shifting and rounding. This is used for hexadecimal
 // numbers since a base 16 exponent multiplied by 4 is the base 2 exponent.
 template <class T>
 static inline void
-binaryExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
+binary_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
                     bool truncated,
                     typename fputil::FPBits<T>::UIntType *outputMantissa,
                     uint32_t *outputExp2) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
 
   // This is the number of leading zeroes a properly normalized float of type T
   // should have.
   constexpr int32_t NUMBITS = sizeof(BitsType) * 8;
   constexpr int32_t INF_EXP =
-      (1 << fputil::FloatProperties<T>::exponentWidth) - 1;
+      (1 << fputil::FloatProperties<T>::EXPONENT_WIDTH) - 1;
 
   // Normalization step 1: Bring the leading bit to the highest bit of BitsType.
-  uint32_t amountToShiftLeft = leadingZeroes<BitsType>(mantissa);
-  mantissa <<= amountToShiftLeft;
+  uint32_t amount_to_shift_left = leading_zeroes<BitsType>(mantissa);
+  mantissa <<= amount_to_shift_left;
 
   // Keep exp2 representing the exponent of the lowest bit of BitsType.
-  exp2 -= amountToShiftLeft;
+  exp2 -= amount_to_shift_left;
 
   // biasedExponent represents the biased exponent of the most significant bit.
-  int32_t biasedExponent = exp2 + NUMBITS + fputil::FPBits<T>::exponentBias - 1;
+  int32_t biased_exponent =
+      exp2 + NUMBITS + fputil::FPBits<T>::EXPONENT_BIAS - 1;
 
   // Handle numbers that're too large and get squashed to inf
-  if (biasedExponent >= INF_EXP) {
+  if (biased_exponent >= INF_EXP) {
     // This indicates an overflow, so we make the result INF and set errno.
-    *outputExp2 = (1 << fputil::FloatProperties<T>::exponentWidth) - 1;
+    *outputExp2 = (1 << fputil::FloatProperties<T>::EXPONENT_WIDTH) - 1;
     *outputMantissa = 0;
     errno = ERANGE;
     return;
   }
 
-  uint32_t amountToShiftRight =
-      NUMBITS - fputil::FloatProperties<T>::mantissaWidth - 1;
+  uint32_t amount_to_shift_right =
+      NUMBITS - fputil::FloatProperties<T>::MANTISSA_WIDTH - 1;
 
   // Handle subnormals.
-  if (biasedExponent <= 0) {
-    amountToShiftRight += 1 - biasedExponent;
-    biasedExponent = 0;
+  if (biased_exponent <= 0) {
+    amount_to_shift_right += 1 - biased_exponent;
+    biased_exponent = 0;
 
-    if (amountToShiftRight > NUMBITS) {
+    if (amount_to_shift_right > NUMBITS) {
       // Return 0 if the exponent is too small.
       *outputMantissa = 0;
       *outputExp2 = 0;
       errno = ERANGE;
       return;
     }
   }
 
-  BitsType roundBitMask = BitsType(1) << (amountToShiftRight - 1);
-  BitsType stickyMask = roundBitMask - 1;
-  bool roundBit = mantissa & roundBitMask;
-  bool stickyBit = static_cast<bool>(mantissa & stickyMask) || truncated;
+  BitsType round_bit_mask = BitsType(1) << (amount_to_shift_right - 1);
+  BitsType sticky_mask = round_bit_mask - 1;
+  bool round_bit = mantissa & round_bit_mask;
+  bool sticky_bit = static_cast<bool>(mantissa & sticky_mask) || truncated;
 
-  if (amountToShiftRight < NUMBITS) {
+  if (amount_to_shift_right < NUMBITS) {
     // Shift the mantissa and clear the implicit bit.
-    mantissa >>= amountToShiftRight;
-    mantissa &= fputil::FloatProperties<T>::mantissaMask;
+    mantissa >>= amount_to_shift_right;
+    mantissa &= fputil::FloatProperties<T>::MANTISSA_MASK;
   } else {
     mantissa = 0;
   }
-  bool leastSignificantBit = mantissa & BitsType(1);
+  bool least_significant_bit = mantissa & BitsType(1);
   // Perform rounding-to-nearest, tie-to-even.
-  if (roundBit && (leastSignificantBit || stickyBit)) {
+  if (round_bit && (least_significant_bit || sticky_bit)) {
     ++mantissa;
   }
 
-  if (mantissa > fputil::FloatProperties<T>::mantissaMask) {
+  if (mantissa > fputil::FloatProperties<T>::MANTISSA_MASK) {
     // Rounding causes the exponent to increase.
-    ++biasedExponent;
+    ++biased_exponent;
 
-    if (biasedExponent == INF_EXP) {
+    if (biased_exponent == INF_EXP) {
       errno = ERANGE;
     }
   }
 
-  if (biasedExponent == 0) {
+  if (biased_exponent == 0) {
     errno = ERANGE;
   }
 
-  *outputMantissa = mantissa & fputil::FloatProperties<T>::mantissaMask;
-  *outputExp2 = biasedExponent;
+  *outputMantissa = mantissa & fputil::FloatProperties<T>::MANTISSA_MASK;
+  *outputExp2 = biased_exponent;
 }
 
 // checks if the next 4 characters of the string pointer are the start of a
 // hexadecimal floating point number. Does not advance the string pointer.
 static inline bool is_float_hex_start(const char *__restrict src,
                                       const char decimalPoint) {
   if (!(*src == '0' && (*(src + 1) | 32) == 'x')) {
     return false;
   }
   if (*(src + 2) == decimalPoint) {
     return isalnum(*(src + 3)) && b36_char_to_int(*(src + 3)) < 16;
   } else {
     return isalnum(*(src + 2)) && b36_char_to_int(*(src + 2)) < 16;
   }
 }
 
 // Takes the start of a string representing a decimal float, as well as the
 // local decimalPoint. It returns if it suceeded in parsing any digits, and if
 // the return value is true then the outputs are pointer to the end of the
 // number, and the mantissa and exponent for the closest float T representation.
 // If the return value is false, then it is assumed that there is no number
 // here.
 template <class T>
 static inline bool
-decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
+decimal_string_to_float(const char *__restrict src, const char DECIMAL_POINT,
                         char **__restrict strEnd,
                         typename fputil::FPBits<T>::UIntType *outputMantissa,
                         uint32_t *outputExponent) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BASE = 10;
   constexpr char EXPONENT_MARKER = 'e';
 
-  const char *__restrict numStart = src;
+  const char *__restrict num_start = src;
   bool truncated = false;
-  bool seenDigit = false;
-  bool afterDecimal = false;
+  bool seen_digit = false;
+  bool after_decimal = false;
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
   // The loop fills the mantissa with as many digits as it can hold
-  const BitsType BITSTYPE_MAX_DIV_BY_BASE =
+  const BitsType bitstype_max_div_by_base =
       __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
   while (true) {
     if (isdigit(*src)) {
       uint32_t digit = *src - '0';
-      seenDigit = true;
+      seen_digit = true;
 
-      if (mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
+      if (mantissa < bitstype_max_div_by_base) {
         mantissa = (mantissa * BASE) + digit;
-        if (afterDecimal) {
+        if (after_decimal) {
           --exponent;
         }
       } else {
         if (digit > 0)
           truncated = true;
-        if (!afterDecimal)
+        if (!after_decimal)
           ++exponent;
       }
 
       ++src;
       continue;
     }
     if (*src == DECIMAL_POINT) {
-      if (afterDecimal) {
+      if (after_decimal) {
         break; // this means that *src points to a second decimal point, ending
                // the number.
       }
-      afterDecimal = true;
+      after_decimal = true;
       ++src;
       continue;
     }
     // The character is neither a digit nor a decimal point.
     break;
   }
 
-  if (!seenDigit)
+  if (!seen_digit)
     return false;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
-      char *tempStrEnd;
-      int32_t add_to_exponent = strtointeger<int32_t>(src, &tempStrEnd, 10);
+      char *temp_str_end;
+      int32_t add_to_exponent = strtointeger<int32_t>(src, &temp_str_end, 10);
       if (add_to_exponent > 100000)
         add_to_exponent = 100000;
       else if (add_to_exponent < -100000)
         add_to_exponent = -100000;
 
-      src = tempStrEnd;
+      src = temp_str_end;
       exponent += add_to_exponent;
     }
   }
 
   *strEnd = const_cast<char *>(src);
   if (mantissa == 0) { // if we have a 0, then also 0 the exponent.
     *outputMantissa = 0;
     *outputExponent = 0;
   } else {
-    decimalExpToFloat<T>(mantissa, exponent, numStart, truncated,
+    decimal_exp_to_float<T>(mantissa, exponent, num_start, truncated,
                             outputMantissa, outputExponent);
   }
   return true;
 }
 
 // Takes the start of a string representing a hexadecimal float, as well as the
 // local decimal point. It returns if it suceeded in parsing any digits, and if
 // the return value is true then the outputs are pointer to the end of the
 // number, and the mantissa and exponent for the closest float T representation.
 // If the return value is false, then it is assumed that there is no number
 // here.
 template <class T>
-static inline bool
-hexadecimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
-                         char **__restrict strEnd,
-                         typename fputil::FPBits<T>::UIntType *outputMantissa,
-                         uint32_t *outputExponent) {
+static inline bool hexadecimal_string_to_float(
+    const char *__restrict src, const char DECIMAL_POINT,
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BASE = 16;
   constexpr char EXPONENT_MARKER = 'p';
 
   bool truncated = false;
-  bool seenDigit = false;
-  bool afterDecimal = false;
+  bool seen_digit = false;
+  bool after_decimal = false;
   BitsType mantissa = 0;
   int32_t exponent = 0;
 
   // The goal for the first step of parsing is to convert the number in src to
   // the format mantissa * (base ^ exponent)
 
   // The loop fills the mantissa with as many digits as it can hold
-  const BitsType BITSTYPE_MAX_DIV_BY_BASE =
+  const BitsType bitstype_max_div_by_base =
       __llvm_libc::cpp::NumericLimits<BitsType>::max() / BASE;
   while (true) {
     if (isalnum(*src)) {
       uint32_t digit = b36_char_to_int(*src);
       if (digit < BASE)
-        seenDigit = true;
+        seen_digit = true;
       else
         break;
 
-      if (mantissa < BITSTYPE_MAX_DIV_BY_BASE) {
+      if (mantissa < bitstype_max_div_by_base) {
         mantissa = (mantissa * BASE) + digit;
-        if (afterDecimal)
+        if (after_decimal)
           --exponent;
       } else {
         if (digit > 0)
           truncated = true;
-        if (!afterDecimal)
+        if (!after_decimal)
           ++exponent;
       }
       ++src;
       continue;
     }
     if (*src == DECIMAL_POINT) {
-      if (afterDecimal) {
+      if (after_decimal) {
         break; // this means that *src points to a second decimal point, ending
                // the number.
       }
-      afterDecimal = true;
+      after_decimal = true;
       ++src;
       continue;
     }
     // The character is neither a hexadecimal digit nor a decimal point.
     break;
   }
 
-  if (!seenDigit)
+  if (!seen_digit)
     return false;
 
   // Convert the exponent from having a base of 16 to having a base of 2.
   exponent *= 4;
 
   if ((*src | 32) == EXPONENT_MARKER) {
     if (*(src + 1) == '+' || *(src + 1) == '-' || isdigit(*(src + 1))) {
       ++src;
-      char *tempStrEnd;
-      int32_t add_to_exponent = strtointeger<int32_t>(src, &tempStrEnd, 10);
+      char *temp_str_end;
+      int32_t add_to_exponent = strtointeger<int32_t>(src, &temp_str_end, 10);
       if (add_to_exponent > 100000)
         add_to_exponent = 100000;
       else if (add_to_exponent < -100000)
         add_to_exponent = -100000;
-      src = tempStrEnd;
+      src = temp_str_end;
       exponent += add_to_exponent;
     }
   }
   *strEnd = const_cast<char *>(src);
   if (mantissa == 0) { // if we have a 0, then also 0 the exponent.
     *outputMantissa = 0;
     *outputExponent = 0;
   } else {
-    binaryExpToFloat<T>(mantissa, exponent, truncated, outputMantissa,
+    binary_exp_to_float<T>(mantissa, exponent, truncated, outputMantissa,
                            outputExponent);
   }
   return true;
 }
 
 // Takes a pointer to a string and a pointer to a string pointer. This function
 // is used as the backend for all of the string to float functions.
 template <class T>
 static inline T strtofloatingpoint(const char *__restrict src,
                                    char **__restrict strEnd) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
   fputil::FPBits<T> result = fputil::FPBits<T>();
-  const char *originalSrc = src;
-  bool seenDigit = false;
+  const char *original_src = src;
+  bool seen_digit = false;
   src = first_non_whitespace(src);
 
   if (*src == '+' || *src == '-') {
     if (*src == '-') {
-      result.setSign(true);
+      result.set_sign(true);
     }
     ++src;
   }
 
   static constexpr char DECIMAL_POINT = '.';
-  static const char *INF_STRING = "infinity";
-  static const char *NAN_STRING = "nan";
+  static const char *inf_string = "infinity";
+  static const char *nan_string = "nan";
 
   // bool truncated = false;
 
   if (isdigit(*src) || *src == DECIMAL_POINT) { // regular number
     int base = 10;
     if (is_float_hex_start(src, DECIMAL_POINT)) {
       base = 16;
       src += 2;
-      seenDigit = true;
+      seen_digit = true;
     }
-    char *newStrEnd = nullptr;
+    char *new_str_end = nullptr;
 
-    BitsType outputMantissa = 0;
-    uint32_t outputExponent = 0;
+    BitsType output_mantissa = 0;
+    uint32_t output_exponent = 0;
     if (base == 16) {
-      seenDigit = hexadecimalStringToFloat<T>(src, DECIMAL_POINT, &newStrEnd,
-                                              &outputMantissa, &outputExponent);
+      seen_digit = hexadecimal_string_to_float<T>(
+          src, DECIMAL_POINT, &new_str_end, &output_mantissa, &output_exponent);
     } else { // base is 10
-      seenDigit = decimalStringToFloat<T>(src, DECIMAL_POINT, &newStrEnd,
-                                          &outputMantissa, &outputExponent);
+      seen_digit = decimal_string_to_float<T>(
+          src, DECIMAL_POINT, &new_str_end, &output_mantissa, &output_exponent);
     }
 
-    if (seenDigit) {
-      src += newStrEnd - src;
-      result.setMantissa(outputMantissa);
-      result.setUnbiasedExponent(outputExponent);
+    if (seen_digit) {
+      src += new_str_end - src;
+      result.set_mantissa(output_mantissa);
+      result.set_unbiased_exponent(output_exponent);
     }
   } else if ((*src | 32) == 'n') { // NaN
-    if ((src[1] | 32) == NAN_STRING[1] && (src[2] | 32) == NAN_STRING[2]) {
-      seenDigit = true;
+    if ((src[1] | 32) == nan_string[1] && (src[2] | 32) == nan_string[2]) {
+      seen_digit = true;
       src += 3;
-      BitsType NaNMantissa = 0;
+      BitsType nan_mantissa = 0;
       // this handles the case of `NaN(n-character-sequence)`, where the
       // n-character-sequence is made of 0 or more letters and numbers in any
       // order.
       if (*src == '(') {
-        const char *leftParen = src;
+        const char *left_paren = src;
         ++src;
         while (isalnum(*src))
           ++src;
         if (*src == ')') {
           ++src;
-          char *tempSrc = 0;
-          if (isdigit(*(leftParen + 1))) {
+          char *temp_src = 0;
+          if (isdigit(*(left_paren + 1))) {
             // This is to prevent errors when BitsType is larger than 64 bits,
             // since strtointeger only supports up to 64 bits. This is actually
             // more than is required by the specification, which says for the
             // input type "NAN(n-char-sequence)" that "the meaning of
             // the n-char sequence is implementation-defined."
-            NaNMantissa = static_cast<BitsType>(
-                strtointeger<uint64_t>(leftParen + 1, &tempSrc, 0));
-            if (*tempSrc != ')')
-              NaNMantissa = 0;
+            nan_mantissa = static_cast<BitsType>(
+                strtointeger<uint64_t>(left_paren + 1, &temp_src, 0));
+            if (*temp_src != ')')
+              nan_mantissa = 0;
           }
         } else
-          src = leftParen;
+          src = left_paren;
       }
-      NaNMantissa |= fputil::FloatProperties<T>::quietNaNMask;
-      if (result.getSign()) {
-        result = fputil::FPBits<T>(result.buildNaN(NaNMantissa));
-        result.setSign(true);
+      nan_mantissa |= fputil::FloatProperties<T>::QUIET_NAN_MASK;
+      if (result.get_sign()) {
+        result = fputil::FPBits<T>(result.build_nan(nan_mantissa));
+        result.set_sign(true);
       } else {
-        result.setSign(false);
-        result = fputil::FPBits<T>(result.buildNaN(NaNMantissa));
+        result.set_sign(false);
+        result = fputil::FPBits<T>(result.build_nan(nan_mantissa));
       }
     }
   } else if ((*src | 32) == 'i') { // INF
-    if ((src[1] | 32) == INF_STRING[1] && (src[2] | 32) == INF_STRING[2]) {
-      seenDigit = true;
-      if (result.getSign())
-        result = result.negInf();
+    if ((src[1] | 32) == inf_string[1] && (src[2] | 32) == inf_string[2]) {
+      seen_digit = true;
+      if (result.get_sign())
+        result = result.neg_inf();
       else
         result = result.inf();
-      if ((src[3] | 32) == INF_STRING[3] && (src[4] | 32) == INF_STRING[4] &&
-          (src[5] | 32) == INF_STRING[5] && (src[6] | 32) == INF_STRING[6] &&
-          (src[7] | 32) == INF_STRING[7]) {
+      if ((src[3] | 32) == inf_string[3] && (src[4] | 32) == inf_string[4] &&
+          (src[5] | 32) == inf_string[5] && (src[6] | 32) == inf_string[6] &&
+          (src[7] | 32) == inf_string[7]) {
         // if the string is "INFINITY" then strEnd needs to be set to src + 8.
         src += 8;
       } else {
         src += 3;
       }
     }
   }
-  if (!seenDigit) { // If there is nothing to actually parse, then return 0.
+  if (!seen_digit) { // If there is nothing to actually parse, then return 0.
     if (strEnd != nullptr)
-      *strEnd = const_cast<char *>(originalSrc);
+      *strEnd = const_cast<char *>(original_src);
     return T(0);
   }
 
   if (strEnd != nullptr)
     *strEnd = const_cast<char *>(src);
 
   return T(result);
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_SUPPORT_STR_TO_FLOAT_H

libc/src/__support/str_to_integer.h

static inline T strtointeger(const char *__restrict src,
   }
 
   if (base == 0) {
     base = infer_base(&src);
   } else if (base == 16 && is_hex_start(src)) {
     src = src + 2;
   }
 
-  constexpr bool is_unsigned = (__llvm_libc::cpp::NumericLimits<T>::min() == 0);
+  constexpr bool IS_UNSIGNED = (__llvm_libc::cpp::NumericLimits<T>::min() == 0);
   const bool is_positive = (result_sign == '+');
   unsigned long long constexpr NEGATIVE_MAX =
-      !is_unsigned ? static_cast<unsigned long long>(
+      !IS_UNSIGNED ? static_cast<unsigned long long>(
                          __llvm_libc::cpp::NumericLimits<T>::max()) +
                          1
                    : __llvm_libc::cpp::NumericLimits<T>::max();
-  unsigned long long const ABS_MAX =
+  unsigned long long const abs_max =
       (is_positive ? __llvm_libc::cpp::NumericLimits<T>::max() : NEGATIVE_MAX);
-  unsigned long long const ABS_MAX_DIV_BY_BASE = ABS_MAX / base;
+  unsigned long long const abs_max_div_by_base = abs_max / base;
   while (isalnum(*src)) {
     int cur_digit = b36_char_to_int(*src);
     if (cur_digit >= base)
       break;
 
     is_number = true;
     ++src;
 
     // If the number has already hit the maximum value for the current type then
     // the result cannot change, but we still need to advance src to the end of
     // the number.
-    if (result == ABS_MAX) {
+    if (result == abs_max) {
       errno = ERANGE;
       continue;
     }
 
-    if (result > ABS_MAX_DIV_BY_BASE) {
-      result = ABS_MAX;
+    if (result > abs_max_div_by_base) {
+      result = abs_max;
       errno = ERANGE;
     } else {
       result = result * base;
     }
-    if (result > ABS_MAX - cur_digit) {
-      result = ABS_MAX;
+    if (result > abs_max - cur_digit) {
+      result = abs_max;
       errno = ERANGE;
     } else {
       result = result + cur_digit;
     }
   }
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(is_number ? src : original_src);
 
-  if (result == ABS_MAX) {
-    if (is_positive || is_unsigned)
+  if (result == abs_max) {
+    if (is_positive || IS_UNSIGNED)
       return __llvm_libc::cpp::NumericLimits<T>::max();
     else // T is signed and there is a negative overflow
       return __llvm_libc::cpp::NumericLimits<T>::min();
   }
 
   return is_positive ? static_cast<T>(result) : -static_cast<T>(result);
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LIBC_SRC_SUPPORT_STR_TO_INTEGER_H

libc/src/assert/__assert_fail.cpp

 #include "config/linux/syscall.h" // For internal syscall function.
 #include "include/sys/syscall.h"  // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This is just a temporary solution to make assert available to internal
 // llvm libc code. In the future writeToStderr will not exist and __assert_fail
 // will call fprintf(stderr, ...).
-static void writeToStderr(const char *s) {
+static void write_to_stderr(const char *s) {
   size_t length = 0;
   for (const char *curr = s; *curr; ++curr, ++length);
   __llvm_libc::syscall(SYS_write, 2, s, length);
 }
 
 LLVM_LIBC_FUNCTION(void, __assert_fail,
                    (const char *assertion, const char *file, unsigned line,
                     const char *function)) {
-  writeToStderr(file);
-  writeToStderr(": Assertion failed: '");
-  writeToStderr(assertion);
-  writeToStderr("' in function: '");
-  writeToStderr(function);
-  writeToStderr("'\n");
+  write_to_stderr(file);
+  write_to_stderr(": Assertion failed: '");
+  write_to_stderr(assertion);
+  write_to_stderr("' in function: '");
+  write_to_stderr(function);
+  write_to_stderr("'\n");
   __llvm_libc::abort();
 }
 
 } // namespace __llvm_libc

libc/src/errno/__errno_location.cpp

 //===-- Implementation of __errno_location --------------------------------===//
 //
 // 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 "src/errno/__errno_location.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-static thread_local int __errno = 0;
+static thread_local int errno = 0;
 
 // __errno_location is not really an entry point but we still want it to behave
 // like an entry point because the errno macro resolves to the C symbol
 // "__errno_location".
-LLVM_LIBC_FUNCTION(int *, __errno_location, ()) { return &__errno; }
+LLVM_LIBC_FUNCTION(int *, __errno_location, ()) { return &errno; }
 
 } // namespace __llvm_libc

libc/src/fenv/feclearexcept.cpp

 //===-- Implementation of feclearexcept function --------------------------===//
 //
 // 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 "src/fenv/feclearexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feclearexcept, (int e)) {
-  return fputil::clearExcept(e);
+  return fputil::clear_except(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fedisableexcept.cpp

 //===-- Implementation of fedisableexcept function ------------------------===//
 //
 // 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 "src/fenv/fedisableexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fedisableexcept, (int e)) {
-  return fputil::disableExcept(e);
+  return fputil::disable_except(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/feenableexcept.cpp

 //===-- Implementation of feenableexcept function -------------------------===//
 //
 // 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 "src/fenv/feenableexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feenableexcept, (int e)) {
-  return fputil::enableExcept(e);
+  return fputil::enable_except(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetenv.cpp

 //===-- Implementation of fegetenv function -----------------------------===//
 //
 // 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 "src/fenv/fegetenv.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fegetenv, (fenv_t * envp)) {
-  return fputil::getEnv(envp);
+  return fputil::get_env(envp);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetexcept.cpp

 //===-- Implementation of fegetexcept function ----------------------------===//
 //
 // 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 "src/fenv/fegetexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, fegetexcept, ()) { return fputil::getExcept(); }
+LLVM_LIBC_FUNCTION(int, fegetexcept, ()) { return fputil::get_except(); }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetexceptflag.cpp

 #include "src/__support/common.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fegetexceptflag, (fexcept_t * flagp, int excepts)) {
   // TODO: Add a compile time check to see if the excepts actually fit in flagp.
-  *flagp = static_cast<fexcept_t>(fputil::testExcept(FE_ALL_EXCEPT) & excepts);
+  *flagp = static_cast<fexcept_t>(fputil::test_except(FE_ALL_EXCEPT) & excepts);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetround.cpp

 //===-- Implementation of fegetround function -----------------------------===//
 //
 // 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 "src/fenv/fegetround.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::getRound(); }
+LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::get_round(); }
 
 } // namespace __llvm_libc

libc/src/fenv/feholdexcept.cpp

 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feholdexcept, (fenv_t * envp)) {
-  if (fputil::getEnv(envp) != 0)
+  if (fputil::get_env(envp) != 0)
     return -1;
-  fputil::clearExcept(FE_ALL_EXCEPT);
-  fputil::disableExcept(FE_ALL_EXCEPT);
+  fputil::clear_except(FE_ALL_EXCEPT);
+  fputil::disable_except(FE_ALL_EXCEPT);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/fenv/feraiseexcept.cpp

 //===-- Implementation of feraiseexcept function --------------------------===//
 //
 // 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 "src/fenv/feraiseexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feraiseexcept, (int e)) {
-  return fputil::raiseExcept(e);
+  return fputil::raise_except(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fesetenv.cpp

 //===-- Implementation of fesetenv function -----------------------------===//
 //
 // 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 "src/fenv/fesetenv.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fesetenv, (const fenv_t *envp)) {
-  return fputil::setEnv(envp);
+  return fputil::set_env(envp);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fesetexceptflag.cpp

 
 LLVM_LIBC_FUNCTION(int, fesetexceptflag,
                    (const fexcept_t *flagp, int excepts)) {
   // Since the return type of fetestexcept is int, we ensure that fexcept_t
   // can fit in int type.
   static_assert(sizeof(int) >= sizeof(fexcept_t),
                 "fexcept_t value cannot fit in an int value.");
   int excepts_to_set = static_cast<const int>(*flagp) & excepts;
-  fputil::clearExcept(FE_ALL_EXCEPT);
-  return fputil::setExcept(excepts_to_set);
+  fputil::clear_except(FE_ALL_EXCEPT);
+  return fputil::set_except(excepts_to_set);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fesetround.cpp

 //===-- Implementation of fesetround function -----------------------------===//
 //
 // 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 "src/fenv/fesetround.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, fesetround, (int m)) { return fputil::setRound(m); }
+LLVM_LIBC_FUNCTION(int, fesetround, (int m)) { return fputil::set_round(m); }
 
 } // namespace __llvm_libc

libc/src/fenv/fetestexcept.cpp

 //===-- Implementation of fetestexcept function ---------------------------===//
 //
 // 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 "src/fenv/fetestexcept.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, fetestexcept, (int e)) { return fputil::testExcept(e); }
+LLVM_LIBC_FUNCTION(int, fetestexcept, (int e)) {
+  return fputil::test_except(e);
+}
 
 } // namespace __llvm_libc

libc/src/fenv/feupdateenv.cpp

 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feupdateenv, (const fenv_t *envp)) {
-  int current_excepts = fputil::testExcept(FE_ALL_EXCEPT);
-  if (fputil::setEnv(envp) != 0)
+  int current_excepts = fputil::test_except(FE_ALL_EXCEPT);
+  if (fputil::set_env(envp) != 0)
     return -1;
-  return fputil::raiseExcept(current_excepts);
+  return fputil::raise_except(current_excepts);
 }
 
 } // namespace __llvm_libc

libc/src/inttypes/imaxdiv.cpp

 //===-- Implementation of imaxdiv -----------------------------------------===//
 //
 // 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 "src/inttypes/imaxdiv.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(imaxdiv_t, imaxdiv, (intmax_t x, intmax_t y)) {
   imaxdiv_t res;
-  integerRemQuo(x, y, res.quot, res.rem);
+  integer_rem_quo(x, y, res.quot, res.rem);
   return res;
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/cosf.cpp

 // Fast cosf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer
 // arithmetic.
 LLVM_LIBC_FUNCTION(float, cosf, (float y)) {
   double x = y;
   double s;
   int n;
-  const sincos_t *p = &__sincosf_table[0];
+  const sincos_t *p = &__SINCOSF_TABLE[0];
 
   if (abstop12(y) < abstop12(pio4)) {
     double x2 = x * x;
 
     if (unlikely(abstop12(y) < abstop12(as_float(0x39800000))))
       return 1.0f;
 
     return sinf_poly(x, x2, p, 1);
   } else if (likely(abstop12(y) < abstop12(120.0f))) {
     x = reduce_fast(x, p, &n);
 
     // Setup the signs for sin and cos.
     s = p->sign[n & 3];
 
     if (n & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     return sinf_poly(x * s, x * x, p, n ^ 1);
   } else if (abstop12(y) < abstop12(INFINITY)) {
     uint32_t xi = as_uint32_bits(y);
     int sign = xi >> 31;
 
     x = reduce_large(xi, &n);
 
     // Setup signs for sin and cos - include original sign.
     s = p->sign[(n + sign) & 3];
 
     if ((n + sign) & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     return sinf_poly(x * s, x * x, p, n ^ 1);
   }
 
   return invalid(y);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/dp_trig.cpp

 // contribute integral results in the operation x * 1/y. This helps us get
 // accurate values of F even when x is a very large number.
 //
 // Internal operations are performed at 192 bits of precision.
 static double mod_impl(double x, const uint64_t y_bits[3],
                        const uint64_t inv_y_bits[20], int y_exponent,
                        int inv_y_exponent) {
   FPBits bits(x);
-  int exponent = bits.getExponent();
+  int exponent = bits.get_exponent();
   int bit_drop = (exponent - 52) + inv_y_exponent + 1;
   bit_drop = bit_drop >= 0 ? bit_drop : 0;
   int word_drop = bit_drop / 64;
   bit_drop %= 64;
   fputil::UInt<256> man4;
   for (size_t i = 0; i < 4; ++i) {
     man4[3 - i] = inv_y_bits[word_drop + i];
   }

libc/src/math/generic/expm1f.cpp

 // subtraction expf(x) - 1.0f, so we use it to compute expm1f(x).
 //
 // We divide [-Ln2; Ln2] into 3 subintervals [-Ln2; -1/8], [-1/8; 1/8],
 // [1/8; Ln2]. And we use a degree-6 polynomial to approximate exp(x) - 1 in
 // each interval. The coefficients were generated by Sollya's fpminmax.
 //
 // See libc/utils/mathtools/expm1f.sollya for more detail.
 LLVM_LIBC_FUNCTION(float, expm1f, (float x)) {
-  const float Ln2 =
+  const float ln2 =
       0.69314718055994530941723212145817656807550013436025f; // For C++17:
                                                              // 0x1.62e'42ffp-1
   float abs_x = __llvm_libc::fputil::abs(x);
 
-  if (abs_x <= Ln2) {
+  if (abs_x <= ln2) {
     if (abs_x <= 0.125f) {
       return x * __llvm_libc::fputil::polyeval(
                      x, 1.0f, 0.5f, 0.16666664183139801025390625f,
                      4.1666664183139801025390625e-2f,
                      8.3379410207271575927734375e-3f,
                      1.3894210569560527801513671875e-3f);
     }
     if (x > 0.125f) {

libc/src/math/generic/llrint.cpp

 //===-- Implementation of llrint function ---------------------------------===//
 //
 // 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 "src/math/llrint.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llrint, (double x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double,
-                                                              long long>(x);
+  return fputil::round_to_signed_integer_using_current_rounding_mode<double,
+                                                                     long long>(
+      x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/llrintf.cpp

 //===-- Implementation of llrintf function --------------------------------===//
 //
 // 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 "src/math/llrintf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llrintf, (float x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>(
+  return fputil::round_to_signed_integer_using_current_rounding_mode<float,
+                                                                     long long>(
       x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/llrintl.cpp

 //===-- Implementation of llrintl function --------------------------------===//
 //
 // 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 "src/math/llrintl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llrintl, (long double x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
-                                                              long long>(x);
+  return fputil::round_to_signed_integer_using_current_rounding_mode<
+      long double, long long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/llround.cpp

 //===-- Implementation of llround function --------------------------------===//
 //
 // 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 "src/math/llround.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llround, (double x)) {
-  return fputil::roundToSignedInteger<double, long long>(x);
+  return fputil::round_to_signed_integer<double, long long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/llroundf.cpp

 //===-- Implementation of llroundf function -------------------------------===//
 //
 // 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 "src/math/llroundf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llroundf, (float x)) {
-  return fputil::roundToSignedInteger<float, long long>(x);
+  return fputil::round_to_signed_integer<float, long long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/llroundl.cpp

 //===-- Implementation of llroundl function -------------------------------===//
 //
 // 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 "src/math/llroundl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, llroundl, (long double x)) {
-  return fputil::roundToSignedInteger<long double, long long>(x);
+  return fputil::round_to_signed_integer<long double, long long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lrint.cpp

 //===-- Implementation of lrint function ----------------------------------===//
 //
 // 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 "src/math/lrint.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lrint, (double x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x);
+  return fputil::round_to_signed_integer_using_current_rounding_mode<double,
+                                                                     long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lrintf.cpp

 //===-- Implementation of lrintf function ---------------------------------===//
 //
 // 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 "src/math/lrintf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lrintf, (float x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x);
+  return fputil::round_to_signed_integer_using_current_rounding_mode<float,
+                                                                     long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lrintl.cpp

 //===-- Implementation of lrintl function ---------------------------------===//
 //
 // 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 "src/math/lrintl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lrintl, (long double x)) {
-  return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
-                                                              long>(x);
+  return fputil::round_to_signed_integer_using_current_rounding_mode<
+      long double, long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lround.cpp

 //===-- Implementation of lround function ---------------------------------===//
 //
 // 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 "src/math/lround.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lround, (double x)) {
-  return fputil::roundToSignedInteger<double, long>(x);
+  return fputil::round_to_signed_integer<double, long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lroundf.cpp

 //===-- Implementation of lroundf function --------------------------------===//
 //
 // 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 "src/math/lroundf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lroundf, (float x)) {
-  return fputil::roundToSignedInteger<float, long>(x);
+  return fputil::round_to_signed_integer<float, long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/lroundl.cpp

 //===-- Implementation of lroundl function --------------------------------===//
 //
 // 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 "src/math/lroundl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, lroundl, (long double x)) {
-  return fputil::roundToSignedInteger<long double, long>(x);
+  return fputil::round_to_signed_integer<long double, long>(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/math_utils.h

 }
 
 template <typename T> static inline T opt_barrier(T x) {
   volatile T y = x;
   return y;
 }
 
 template <typename T> struct IsFloatOrDouble {
-  static constexpr bool Value =
+  static constexpr bool
+      Value = // NOLINT so that this Value can match the ones for IsSame
       cpp::IsSame<T, float>::Value || cpp::IsSame<T, double>::Value;
 };
 
 template <typename T>
 using EnableIfFloatOrDouble = cpp::EnableIfType<IsFloatOrDouble<T>::Value, int>;
 
 template <typename T, EnableIfFloatOrDouble<T> = 0>
 T xflow(uint32_t sign, T y) {

libc/src/math/generic/nearbyint.cpp

 //===-- Implementation of nearbyint function ------------------------------===//
 //
 // 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 "src/math/nearbyint.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/nearbyintf.cpp

 //===-- Implementation of nearbyintf function -----------------------------===//
 //
 // 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 "src/math/nearbyintf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/nearbyintl.cpp

 //===-- Implementation of nearbyintl function -----------------------------===//
 //
 // 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 "src/math/nearbyintl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/rint.cpp

 //===-- Implementation of rint function -----------------------------------===//
 //
 // 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 "src/math/rint.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(double, rint, (double x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/rintf.cpp

 //===-- Implementation of rintf function ----------------------------------===//
 //
 // 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 "src/math/rintf.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(float, rintf, (float x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/rintl.cpp

 //===-- Implementation of rintl function ----------------------------------===//
 //
 // 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 "src/math/rintl.h"
 #include "src/__support/FPUtil/NearestIntegerOperations.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) {
-  return fputil::roundUsingCurrentRoundingMode(x);
+  return fputil::round_using_current_rounding_mode(x);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/sincosf.cpp

 // Fast sincosf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer
 // arithmetic.
 LLVM_LIBC_FUNCTION(void, sincosf, (float y, float *sinp, float *cosp)) {
   double x = y;
   double s;
   int n;
-  const sincos_t *p = &__sincosf_table[0];
+  const sincos_t *p = &__SINCOSF_TABLE[0];
 
   if (abstop12(y) < abstop12(pio4)) {
     double x2 = x * x;
 
     if (unlikely(abstop12(y) < abstop12(as_float(0x39800000)))) {
       if (unlikely(abstop12(y) < abstop12(as_float(0x800000))))
         // Force underflow for tiny y.
         force_eval<float>(x2);
       *sinp = y;
       *cosp = 1.0f;
       return;
     }
 
     sincosf_poly(x, x2, p, 0, sinp, cosp);
   } else if (abstop12(y) < abstop12(120.0f)) {
     x = reduce_fast(x, p, &n);
 
     // Setup the signs for sin and cos.
     s = p->sign[n & 3];
 
     if (n & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     sincosf_poly(x * s, x * x, p, n, sinp, cosp);
   } else if (likely(abstop12(y) < abstop12(INFINITY))) {
     uint32_t xi = as_uint32_bits(y);
     int sign = xi >> 31;
 
     x = reduce_large(xi, &n);
 
     // Setup signs for sin and cos - include original sign.
     s = p->sign[(n + sign) & 3];
 
     if ((n + sign) & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     sincosf_poly(x * s, x * x, p, n, sinp, cosp);
   } else {
     // Return NaN if Inf or NaN for both sin and cos.
     *sinp = *cosp = y - y;
 
     // Needed to set errno for +-Inf, the add is a hack to work
     // around a gcc register allocation issue: just passing y
     // affects code generation in the fast path.
     invalid(y + y);
   }
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/sincosf_data.cpp

 #include "sincosf_utils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // The constants and polynomials for sine and cosine.  The 2nd entry
 // computes -cos (x) rather than cos (x) to get negation for free.
-const sincos_t __sincosf_table[2] = {
+const sincos_t __SINCOSF_TABLE[2] = {
     {{1.0, -1.0, -1.0, 1.0},
      as_double(0x41645f306dc9c883),
      as_double(0x3ff921fb54442d18),
      as_double(0x3ff0000000000000),
      as_double(0xbfdffffffd0c621c),
      as_double(0x3fa55553e1068f19),
      as_double(0xbf56c087e89a359d),
      as_double(0x3ef99343027bf8c3),
const sincos_t __SINCOSF_TABLE[2] = {
      as_double(0xbef99343027bf8c3),
      as_double(0xbfc555545995a603),
      as_double(0x3f81107605230bc4),
      as_double(0xbf2994eb3774cf24)},
 };
 
 // Table with 4/PI to 192 bit precision.  To avoid unaligned accesses
 // only 8 new bits are added per entry, making the table 4 times larger.
-const uint32_t __inv_pio4[24] = {
+const uint32_t __INV_PIO4[24] = {
     0xa2,       0xa2f9,     0xa2f983,   0xa2f9836e, 0xf9836e4e, 0x836e4e44,
     0x6e4e4415, 0x4e441529, 0x441529fc, 0x1529fc27, 0x29fc2757, 0xfc2757d1,
     0x2757d1f5, 0x57d1f534, 0xd1f534dd, 0xf534ddc0, 0x34ddc0db, 0xddc0db62,
     0xc0db6295, 0xdb629599, 0x6295993c, 0x95993c43, 0x993c4390, 0x3c439041};
 
 } // namespace __llvm_libc

libc/src/math/generic/sincosf_utils.h

typedef struct {
   double sign[4];            // Sign of sine in quadrants 0..3.
   double hpi_inv;            // 2 / PI ( * 2^24 ).
   double hpi;                // PI / 2.
   double c0, c1, c2, c3, c4; // Cosine polynomial.
   double s1, s2, s3;         // Sine polynomial.
 } sincos_t;
 
 // Polynomial data (the cosine polynomial is negated in the 2nd entry).
-extern const sincos_t __sincosf_table[2];
+extern const sincos_t __SINCOSF_TABLE[2];
 
 // Table with 4/PI to 192 bit precision.
-extern const uint32_t __inv_pio4[];
+extern const uint32_t __INV_PIO4[];
 
 // Top 12 bits of the float representation with the sign bit cleared.
 static inline uint32_t abstop12(float x) {
   return (as_uint32_bits(x) >> 20) & 0x7ff;
 }
 
 // Compute the sine and cosine of inputs X and X2 (X squared), using the
 // polynomial P and store the results in SINP and COSP. N is the quadrant,

 // Reduce the range of XI to a multiple of PI/2 using fast integer arithmetic.
 // XI is a reinterpreted float and must be >= 2.0f (the sign bit is ignored).
 // Return the modulo between -PI/4 and PI/4 and store the quadrant in NP.
 // Reduction uses a table of 4/PI with 192 bits of precision. A 32x96->128 bit
 // multiply computes the exact 2.62-bit fixed-point modulo. Since the result
 // can have at most 29 leading zeros after the binary point, the double
 // precision result is accurate to 33 bits.
 static inline double reduce_large(uint32_t xi, int *np) {
-  const uint32_t *arr = &__inv_pio4[(xi >> 26) & 15];
+  const uint32_t *arr = &__INV_PIO4[(xi >> 26) & 15];
   int shift = (xi >> 23) & 7;
   uint64_t n, res0, res1, res2;
 
   xi = (xi & 0xffffff) | 0x800000;
   xi <<= shift;
 
   res0 = xi * arr[0];
   res1 = (uint64_t)xi * arr[4];

libc/src/math/generic/sinf.cpp

 // Fast sinf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer
 // arithmetic.
 LLVM_LIBC_FUNCTION(float, sinf, (float y)) {
   double x = y;
   double s;
   int n;
-  const sincos_t *p = &__sincosf_table[0];
+  const sincos_t *p = &__SINCOSF_TABLE[0];
 
   if (abstop12(y) < abstop12(pio4)) {
     s = x * x;
 
     if (unlikely(abstop12(y) < abstop12(as_float(0x39800000)))) {
       if (unlikely(abstop12(y) < abstop12(as_float(0x800000))))
         // Force underflow for tiny y.
         force_eval<float>(s);
       return y;
     }
 
     return sinf_poly(x, s, p, 0);
   } else if (likely(abstop12(y) < abstop12(120.0f))) {
     x = reduce_fast(x, p, &n);
 
     // Setup the signs for sin and cos.
     s = p->sign[n & 3];
 
     if (n & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     return sinf_poly(x * s, x * x, p, n);
   } else if (abstop12(y) < abstop12(INFINITY)) {
     uint32_t xi = as_uint32_bits(y);
     int sign = xi >> 31;
 
     x = reduce_large(xi, &n);
 
     // Setup signs for sin and cos - include original sign.
     s = p->sign[(n + sign) & 3];
 
     if ((n + sign) & 2)
-      p = &__sincosf_table[1];
+      p = &__SINCOSF_TABLE[1];
 
     return sinf_poly(x * s, x * x, p, n);
   }
 
   return invalid(y);
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaction.cpp

 namespace __llvm_libc {
 
 // TOOD: Some architectures will have their signal trampoline functions in the
 // vdso, use those when available.
 
 extern "C" void __restore_rt();
 
 template <typename T, typename V>
-static void copySigaction(T &dest, const V &source) {
+static void copy_sigaction(T &dest, const V &source) {
   dest.sa_handler = source.sa_handler;
   dest.sa_mask = source.sa_mask;
   dest.sa_flags = source.sa_flags;
   dest.sa_restorer = source.sa_restorer;
 }
 
 LLVM_LIBC_FUNCTION(int, sigaction,
                    (int signal, const struct __sigaction *__restrict libc_new,
                     struct __sigaction *__restrict libc_old)) {
   struct sigaction kernel_new;
   if (libc_new) {
-    copySigaction(kernel_new, *libc_new);
+    copy_sigaction(kernel_new, *libc_new);
     if (!(kernel_new.sa_flags & SA_RESTORER)) {
       kernel_new.sa_flags |= SA_RESTORER;
       kernel_new.sa_restorer = __restore_rt;
     }
   }
 
   struct sigaction kernel_old;
   int ret = syscall(SYS_rt_sigaction, signal, libc_new ? &kernel_new : nullptr,
                     libc_old ? &kernel_old : nullptr, sizeof(sigset_t));
   if (ret) {
     llvmlibc_errno = -ret;
     return -1;
   }
 
   if (libc_old)
-    copySigaction(*libc_old, kernel_old);
+    copy_sigaction(*libc_old, kernel_old);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigemptyset.cpp

 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigemptyset, (sigset_t * set)) {
   if (!set) {
     llvmlibc_errno = EINVAL;
     return -1;
   }
-  *set = __llvm_libc::Sigset::emptySet();
+  *set = __llvm_libc::Sigset::empty_set();
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/signal.h

 
 static_assert(sizeof(sigset_t) * 8 >= NSIG, "sigset_t cannot hold all signals");
 
 namespace __llvm_libc {
 
 // Using this internally defined type will make it easier in the future to port
 // to different architectures.
 struct Sigset {
-  sigset_t nativeSigset;
+  sigset_t native_sigset;
 
   constexpr static Sigset fullset() { return {-1UL}; }
-  constexpr static Sigset emptySet() { return {0}; }
+  constexpr static Sigset empty_set() { return {0}; }
 
-  constexpr void addset(int signal) { nativeSigset |= (1L << (signal - 1)); }
+  constexpr void addset(int signal) { native_sigset |= (1L << (signal - 1)); }
 
-  constexpr void delset(int signal) { nativeSigset &= ~(1L << (signal - 1)); }
+  constexpr void delset(int signal) { native_sigset &= ~(1L << (signal - 1)); }
 
-  operator sigset_t() const { return nativeSigset; }
+  operator sigset_t() const { return native_sigset; }
 };
 
-constexpr static Sigset all = Sigset::fullset();
+constexpr static Sigset ALL = Sigset::fullset();
 
 static inline int block_all_signals(Sigset &set) {
-  sigset_t nativeSigset = all;
-  sigset_t oldSet = set;
-  int ret = __llvm_libc::syscall(SYS_rt_sigprocmask, SIG_BLOCK, &nativeSigset,
-                                 &oldSet, sizeof(sigset_t));
-  set = {oldSet};
+  sigset_t native_sigset = ALL;
+  sigset_t old_set = set;
+  int ret = __llvm_libc::syscall(SYS_rt_sigprocmask, SIG_BLOCK, &native_sigset,
+                                 &old_set, sizeof(sigset_t));
+  set = {old_set};
   return ret;
 }
 
 static inline int restore_signals(const Sigset &set) {
-  sigset_t nativeSigset = set;
-  return __llvm_libc::syscall(SYS_rt_sigprocmask, SIG_SETMASK, &nativeSigset,
+  sigset_t native_sigset = set;
+  return __llvm_libc::syscall(SYS_rt_sigprocmask, SIG_SETMASK, &native_sigset,
                               nullptr, sizeof(sigset_t));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_H

libc/src/stdlib/abs.cpp

 //===-- Implementation of abs ---------------------------------------------===//
 //
 // 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 "src/stdlib/abs.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, abs, (int n)) { return integerAbs(n); }
+LLVM_LIBC_FUNCTION(int, abs, (int n)) { return integer_abs(n); }
 
 } // namespace __llvm_libc

libc/src/stdlib/div.cpp

 //===-- Implementation of div ---------------------------------------------===//
 //
 // 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 "src/stdlib/div.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(div_t, div, (int x, int y)) {
   div_t res;
-  integerRemQuo(x, y, res.quot, res.rem);
+  integer_rem_quo(x, y, res.quot, res.rem);
   return res;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/labs.cpp

 //===-- Implementation of labs --------------------------------------------===//
 //
 // 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 "src/stdlib/labs.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(long, labs, (long n)) { return integerAbs(n); }
+LLVM_LIBC_FUNCTION(long, labs, (long n)) { return integer_abs(n); }
 
 } // namespace __llvm_libc

libc/src/stdlib/ldiv.cpp

 //===-- Implementation of ldiv --------------------------------------------===//
 //
 // 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 "src/stdlib/ldiv.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ldiv_t, ldiv, (long x, long y)) {
   ldiv_t res;
-  integerRemQuo(x, y, res.quot, res.rem);
+  integer_rem_quo(x, y, res.quot, res.rem);
   return res;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/llabs.cpp

 //===-- Implementation of llabs -------------------------------------------===//
 //
 // 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 "src/stdlib/llabs.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(long long, llabs, (long long n)) { return integerAbs(n); }
+LLVM_LIBC_FUNCTION(long long, llabs, (long long n)) { return integer_abs(n); }
 
 } // namespace __llvm_libc

libc/src/stdlib/lldiv.cpp

 //===-- Implementation of lldiv -------------------------------------------===//
 //
 // 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 "src/stdlib/lldiv.h"
 #include "src/__support/common.h"
 #include "src/__support/integer_operations.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(lldiv_t, lldiv, (long long x, long long y)) {
   lldiv_t res;
-  integerRemQuo(x, y, res.quot, res.rem);
+  integer_rem_quo(x, y, res.quot, res.rem);
   return res;
 }
 
 } // namespace __llvm_libc

libc/src/string/memccpy.cpp

 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memccpy,
                    (void *__restrict dest, const void *__restrict src, int c,
                     size_t count)) {
   unsigned char end = static_cast<unsigned char>(c);
-  const unsigned char *ucSrc = static_cast<const unsigned char *>(src);
-  unsigned char *ucDest = static_cast<unsigned char *>(dest);
+  const unsigned char *uc_src = static_cast<const unsigned char *>(src);
+  unsigned char *uc_dest = static_cast<unsigned char *>(dest);
   size_t i = 0;
   // Copy up until end is found.
-  for (; i < count && ucSrc[i] != end; ++i)
-    ucDest[i] = ucSrc[i];
+  for (; i < count && uc_src[i] != end; ++i)
+    uc_dest[i] = uc_src[i];
   // if i < count, then end must have been found, so copy end into dest and
   // return the byte after.
   if (i < count) {
-    ucDest[i] = ucSrc[i];
-    return ucDest + i + 1;
+    uc_dest[i] = uc_src[i];
+    return uc_dest + i + 1;
   }
   return nullptr;
 }
 
 } // namespace __llvm_libc

libc/src/string/memmove.cpp

LLVM_LIBC_FUNCTION(void *, memmove,
   // If the distance between `src_c` and `dest_c` is equal to or greater
   // than `count` (integerAbs(src_c - dest_c) >= count), they would not overlap.
   // e.g.   greater     equal       overlapping
   //        [12345678]  [12345678]  [12345678]
   // src_c: [_ab_____]  [_ab_____]  [_ab_____]
   // dest_c:[_____yz_]  [___yz___]  [__yz____]
 
   // Call `memcpy` if `src_c` and `dest_c` do not overlap.
-  if (__llvm_libc::integerAbs(src_c - dest_c) >=
+  if (__llvm_libc::integer_abs(src_c - dest_c) >=
       static_cast<ptrdiff_t>(count)) {
     inline_memcpy(dest_c, src_c, count);
     return dest_c;
   }
 
   // Overlapping cases.
   // If `dest_c` starts before `src_c` (dest_c < src_c), copy
   // forward(pointer add 1) from beginning to end.

libc/src/string/memory_utils/bcmp_implementations.h

 #include "src/__support/common.h"
 #include "src/string/memory_utils/elements.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 // Fixed-size difference between 'lhs' and 'rhs'.
-template <typename Element> bool Differs(const char *lhs, const char *rhs) {
-  return !Element::Equals(lhs, rhs);
+template <typename Element> bool differs(const char *lhs, const char *rhs) {
+  return !Element::equals(lhs, rhs);
 }
 // Runtime-size difference between 'lhs' and 'rhs'.
 template <typename Element>
-bool Differs(const char *lhs, const char *rhs, size_t size) {
-  return !Element::Equals(lhs, rhs, size);
+bool differs(const char *lhs, const char *rhs, size_t size) {
+  return !Element::equals(lhs, rhs, size);
 }
 
 static inline int inline_bcmp(const char *lhs, const char *rhs, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86)
   using namespace ::__llvm_libc::x86;
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   using namespace ::__llvm_libc::aarch64;
 #else
   using namespace ::__llvm_libc::scalar;
 #endif
   if (count == 0)
     return 0;
   if (count == 1)
-    return Differs<_1>(lhs, rhs);
+    return differs<_1>(lhs, rhs);
   if (count == 2)
-    return Differs<_2>(lhs, rhs);
+    return differs<_2>(lhs, rhs);
   if (count == 3)
-    return Differs<_3>(lhs, rhs);
+    return differs<_3>(lhs, rhs);
   if (count <= 8)
-    return Differs<HeadTail<_4>>(lhs, rhs, count);
+    return differs<HeadTail<_4>>(lhs, rhs, count);
   if (count <= 16)
-    return Differs<HeadTail<_8>>(lhs, rhs, count);
+    return differs<HeadTail<_8>>(lhs, rhs, count);
   if (count <= 32)
-    return Differs<HeadTail<_16>>(lhs, rhs, count);
+    return differs<HeadTail<_16>>(lhs, rhs, count);
   if (count <= 64)
-    return Differs<HeadTail<_32>>(lhs, rhs, count);
+    return differs<HeadTail<_32>>(lhs, rhs, count);
   if (count <= 128)
-    return Differs<HeadTail<_64>>(lhs, rhs, count);
-  return Differs<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
+    return differs<HeadTail<_64>>(lhs, rhs, count);
+  return differs<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/elements.h

 // --------------------------------
 // We define abstract elementary operations acting on fixed chunks of memory.
 // These are low level building blocks that are meant to be assembled to compose
 // higher order abstractions. Each function is defined twice: once with
 // fixed-size operations, and once with runtime-size operations.
 
 // Fixed-size copy from 'src' to 'dst'.
 template <typename Element>
-void Copy(char *__restrict dst, const char *__restrict src) {
-  Element::Copy(dst, src);
+void copy(char *__restrict dst, const char *__restrict src) {
+  Element::copy(dst, src);
 }
 // Runtime-size copy from 'src' to 'dst'.
 template <typename Element>
-void Copy(char *__restrict dst, const char *__restrict src, size_t size) {
-  Element::Copy(dst, src, size);
+void copy(char *__restrict dst, const char *__restrict src, size_t size) {
+  Element::copy(dst, src, size);
 }
 
 // Fixed-size move from 'src' to 'dst'.
-template <typename Element> void Move(char *dst, const char *src) {
-  Element::Move(dst, src);
+template <typename Element> void move(char *dst, const char *src) {
+  Element::move(dst, src);
 }
 // Runtime-size move from 'src' to 'dst'.
-template <typename Element> void Move(char *dst, const char *src, size_t size) {
-  Element::Move(dst, src, size);
+template <typename Element> void move(char *dst, const char *src, size_t size) {
+  Element::move(dst, src, size);
 }
 
 // Fixed-size equality between 'lhs' and 'rhs'.
-template <typename Element> bool Equals(const char *lhs, const char *rhs) {
-  return Element::Equals(lhs, rhs);
+template <typename Element> bool equals(const char *lhs, const char *rhs) {
+  return Element::equals(lhs, rhs);
 }
 // Runtime-size equality between 'lhs' and 'rhs'.
 template <typename Element>
-bool Equals(const char *lhs, const char *rhs, size_t size) {
-  return Element::Equals(lhs, rhs, size);
+bool equals(const char *lhs, const char *rhs, size_t size) {
+  return Element::equals(lhs, rhs, size);
 }
 
 // Fixed-size three-way comparison between 'lhs' and 'rhs'.
 template <typename Element>
-int ThreeWayCompare(const char *lhs, const char *rhs) {
-  return Element::ThreeWayCompare(lhs, rhs);
+int three_way_compare(const char *lhs, const char *rhs) {
+  return Element::three_way_compare(lhs, rhs);
 }
 // Runtime-size three-way comparison between 'lhs' and 'rhs'.
 template <typename Element>
-int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
-  return Element::ThreeWayCompare(lhs, rhs, size);
+int three_way_compare(const char *lhs, const char *rhs, size_t size) {
+  return Element::three_way_compare(lhs, rhs, size);
 }
 
 // Fixed-size initialization.
 template <typename Element>
-void SplatSet(char *dst, const unsigned char value) {
-  Element::SplatSet(dst, value);
+void splat_set(char *dst, const unsigned char value) {
+  Element::splat_set(dst, value);
 }
 // Runtime-size initialization.
 template <typename Element>
-void SplatSet(char *dst, const unsigned char value, size_t size) {
-  Element::SplatSet(dst, value, size);
+void splat_set(char *dst, const unsigned char value, size_t size) {
+  Element::splat_set(dst, value, size);
 }
 
 // Stack placeholder for Move operations.
-template <typename Element> struct Storage { char bytes[Element::kSize]; };
+template <typename Element> struct Storage { char bytes[Element::SIZE]; };
 
 // Fixed-size Higher-Order Operations
 // ----------------------------------
 // - Repeated<Type, ElementCount>: Repeat the operation several times in a row.
 // - Chained<Types...>: Chain the operation of several types.
 
 // Repeat the operation several times in a row.
 template <typename Element, size_t ElementCount> struct Repeated {
-  static constexpr size_t kSize = ElementCount * Element::kSize;
+  static constexpr size_t SIZE = ElementCount * Element::SIZE;
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
+  static void copy(char *__restrict dst, const char *__restrict src) {
     for (size_t i = 0; i < ElementCount; ++i) {
-      const size_t offset = i * Element::kSize;
-      Element::Copy(dst + offset, src + offset);
+      const size_t offset = i * Element::SIZE;
+      Element::copy(dst + offset, src + offset);
     }
   }
 
-  static void Move(char *dst, const char *src) {
-    const auto Value = Element::Load(src);
-    Repeated<Element, ElementCount - 1>::Move(dst + Element::kSize,
-                                              src + Element::kSize);
-    Element::Store(dst, Value);
+  static void move(char *dst, const char *src) {
+    const auto value = Element::load(src);
+    Repeated<Element, ElementCount - 1>::move(dst + Element::SIZE,
+                                              src + Element::SIZE);
+    Element::store(dst, value);
   }
 
-  static bool Equals(const char *lhs, const char *rhs) {
+  static bool equals(const char *lhs, const char *rhs) {
     for (size_t i = 0; i < ElementCount; ++i) {
-      const size_t offset = i * Element::kSize;
-      if (!Element::Equals(lhs + offset, rhs + offset))
+      const size_t offset = i * Element::SIZE;
+      if (!Element::equals(lhs + offset, rhs + offset))
         return false;
     }
     return true;
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
+  static int three_way_compare(const char *lhs, const char *rhs) {
     for (size_t i = 0; i < ElementCount; ++i) {
-      const size_t offset = i * Element::kSize;
-      // We make the assumption that 'Equals' si cheaper than 'ThreeWayCompare'.
-      if (Element::Equals(lhs + offset, rhs + offset))
+      const size_t offset = i * Element::SIZE;
+      // We make the assumption that 'equals' is cheaper than
+      // 'three_way_compare'.
+      if (Element::equals(lhs + offset, rhs + offset))
         continue;
-      return Element::ThreeWayCompare(lhs + offset, rhs + offset);
+      return Element::three_way_compare(lhs + offset, rhs + offset);
     }
     return 0;
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
+  static void splat_set(char *dst, const unsigned char value) {
     for (size_t i = 0; i < ElementCount; ++i) {
-      const size_t offset = i * Element::kSize;
-      Element::SplatSet(dst + offset, value);
+      const size_t offset = i * Element::SIZE;
+      Element::splat_set(dst + offset, value);
     }
   }
 
-  static Storage<Repeated> Load(const char *ptr) {
+  static Storage<Repeated> load(const char *ptr) {
     Storage<Repeated> value;
-    Copy(reinterpret_cast<char *>(&value), ptr);
+    copy(reinterpret_cast<char *>(&value), ptr);
     return value;
   }
 
-  static void Store(char *ptr, Storage<Repeated> value) {
-    Copy(ptr, reinterpret_cast<const char *>(&value));
+  static void store(char *ptr, Storage<Repeated> value) {
+    copy(ptr, reinterpret_cast<const char *>(&value));
   }
 };
 
 template <typename Element> struct Repeated<Element, 0> {
-  static void Move(char *dst, const char *src) {}
+  static void move(char *dst, const char *src) {}
 };
 
 // Chain the operation of several types.
 // For instance, to handle a 3 bytes operation, one can use:
 // Chained<UINT16, UINT8>::Operation();
 template <typename... Types> struct Chained;
 
 template <typename Head, typename... Tail> struct Chained<Head, Tail...> {
-  static constexpr size_t kSize = Head::kSize + Chained<Tail...>::kSize;
+  static constexpr size_t SIZE = Head::SIZE + Chained<Tail...>::SIZE;
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
-    Chained<Tail...>::Copy(dst + Head::kSize, src + Head::kSize);
-    __llvm_libc::Copy<Head>(dst, src);
+  static void copy(char *__restrict dst, const char *__restrict src) {
+    Chained<Tail...>::copy(dst + Head::SIZE, src + Head::SIZE);
+    __llvm_libc::copy<Head>(dst, src);
   }
 
-  static void Move(char *dst, const char *src) {
-    const auto Value = Head::Load(src);
-    Chained<Tail...>::Move(dst + Head::kSize, src + Head::kSize);
-    Head::Store(dst, Value);
+  static void move(char *dst, const char *src) {
+    const auto value = Head::load(src);
+    Chained<Tail...>::move(dst + Head::SIZE, src + Head::SIZE);
+    Head::store(dst, value);
   }
 
-  static bool Equals(const char *lhs, const char *rhs) {
-    if (!__llvm_libc::Equals<Head>(lhs, rhs))
+  static bool equals(const char *lhs, const char *rhs) {
+    if (!__llvm_libc::equals<Head>(lhs, rhs))
       return false;
-    return Chained<Tail...>::Equals(lhs + Head::kSize, rhs + Head::kSize);
+    return Chained<Tail...>::equals(lhs + Head::SIZE, rhs + Head::SIZE);
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
-    if (__llvm_libc::Equals<Head>(lhs, rhs))
-      return Chained<Tail...>::ThreeWayCompare(lhs + Head::kSize,
-                                               rhs + Head::kSize);
-    return __llvm_libc::ThreeWayCompare<Head>(lhs, rhs);
+  static int three_way_compare(const char *lhs, const char *rhs) {
+    if (__llvm_libc::equals<Head>(lhs, rhs))
+      return Chained<Tail...>::three_way_compare(lhs + Head::SIZE,
+                                                 rhs + Head::SIZE);
+    return __llvm_libc::three_way_compare<Head>(lhs, rhs);
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    Chained<Tail...>::SplatSet(dst + Head::kSize, value);
-    __llvm_libc::SplatSet<Head>(dst, value);
+  static void splat_set(char *dst, const unsigned char value) {
+    Chained<Tail...>::splat_set(dst + Head::SIZE, value);
+    __llvm_libc::splat_set<Head>(dst, value);
   }
 };
 
 template <> struct Chained<> {
-  static constexpr size_t kSize = 0;
-  static void Copy(char *__restrict dst, const char *__restrict src) {}
-  static void Move(char *dst, const char *src) {}
-  static bool Equals(const char *lhs, const char *rhs) { return true; }
-  static int ThreeWayCompare(const char *lhs, const char *rhs) { return 0; }
-  static void SplatSet(char *dst, const unsigned char value) {}
+  static constexpr size_t SIZE = 0;
+  static void copy(char *__restrict dst, const char *__restrict src) {}
+  static void move(char *dst, const char *src) {}
+  static bool equals(const char *lhs, const char *rhs) { return true; }
+  static int three_way_compare(const char *lhs, const char *rhs) { return 0; }
+  static void splat_set(char *dst, const unsigned char value) {}
 };
 
 // Overlap ElementA and ElementB so they span Size bytes.
 template <size_t Size, typename ElementA, typename ElementB = ElementA>
 struct Overlap {
-  static constexpr size_t kSize = Size;
-  static_assert(ElementB::kSize <= ElementA::kSize, "ElementB too big");
-  static_assert(ElementA::kSize <= Size, "ElementA too big");
-  static_assert((ElementA::kSize + ElementB::kSize) >= Size,
+  static constexpr size_t SIZE = Size;
+  static_assert(ElementB::SIZE <= ElementA::SIZE, "ElementB too big");
+  static_assert(ElementA::SIZE <= Size, "ElementA too big");
+  static_assert((ElementA::SIZE + ElementB::SIZE) >= Size,
                 "Elements too small to overlap");
-  static constexpr size_t kOffset = kSize - ElementB::kSize;
+  static constexpr size_t OFFSET = SIZE - ElementB::SIZE;
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
-    ElementA::Copy(dst, src);
-    ElementB::Copy(dst + kOffset, src + kOffset);
+  static void copy(char *__restrict dst, const char *__restrict src) {
+    ElementA::copy(dst, src);
+    ElementB::copy(dst + OFFSET, src + OFFSET);
   }
 
-  static void Move(char *dst, const char *src) {
-    const auto ValueA = ElementA::Load(src);
-    const auto ValueB = ElementB::Load(src + kOffset);
-    ElementB::Store(dst + kOffset, ValueB);
-    ElementA::Store(dst, ValueA);
+  static void move(char *dst, const char *src) {
+    const auto value_a = ElementA::load(src);
+    const auto value_b = ElementB::load(src + OFFSET);
+    ElementB::store(dst + OFFSET, value_b);
+    ElementA::store(dst, value_a);
   }
 
-  static bool Equals(const char *lhs, const char *rhs) {
-    if (!ElementA::Equals(lhs, rhs))
+  static bool equals(const char *lhs, const char *rhs) {
+    if (!ElementA::equals(lhs, rhs))
       return false;
-    if (!ElementB::Equals(lhs + kOffset, rhs + kOffset))
+    if (!ElementB::equals(lhs + OFFSET, rhs + OFFSET))
       return false;
     return true;
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
-    if (!ElementA::Equals(lhs, rhs))
-      return ElementA::ThreeWayCompare(lhs, rhs);
-    if (!ElementB::Equals(lhs + kOffset, rhs + kOffset))
-      return ElementB::ThreeWayCompare(lhs + kOffset, rhs + kOffset);
+  static int three_way_compare(const char *lhs, const char *rhs) {
+    if (!ElementA::equals(lhs, rhs))
+      return ElementA::three_way_compare(lhs, rhs);
+    if (!ElementB::equals(lhs + OFFSET, rhs + OFFSET))
+      return ElementB::three_way_compare(lhs + OFFSET, rhs + OFFSET);
     return 0;
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    ElementA::SplatSet(dst, value);
-    ElementB::SplatSet(dst + kOffset, value);
+  static void splat_set(char *dst, const unsigned char value) {
+    ElementA::splat_set(dst, value);
+    ElementB::splat_set(dst + OFFSET, value);
   }
 };
 
 // Runtime-size Higher-Order Operations
 // ------------------------------------
-// - Tail<T>: Perform the operation on the last 'T::kSize' bytes of the buffer.
-// - HeadTail<T>: Perform the operation on the first and last 'T::kSize' bytes
+// - Tail<T>: Perform the operation on the last 'T::SIZE' bytes of the buffer.
+// - HeadTail<T>: Perform the operation on the first and last 'T::SIZE' bytes
 //   of the buffer.
 // - Loop<T>: Perform a loop of fixed-sized operations.
 
-// Perform the operation on the last 'T::kSize' bytes of the buffer.
+// Perform the operation on the last 'T::SIZE' bytes of the buffer.
 //
 // e.g. with
 // [1234567812345678123]
 // [__XXXXXXXXXXXXXX___]
 // [________XXXXXXXX___]
 //
-// Precondition: `size >= T::kSize`.
+// Precondition: `size >= T::SIZE`.
 template <typename T> struct Tail {
-  static void Copy(char *__restrict dst, const char *__restrict src,
+  static void copy(char *__restrict dst, const char *__restrict src,
                    size_t size) {
-    return T::Copy(dst + offset(size), src + offset(size));
+    return T::copy(dst + offset(size), src + offset(size));
   }
 
-  static bool Equals(const char *lhs, const char *rhs, size_t size) {
-    return T::Equals(lhs + offset(size), rhs + offset(size));
+  static bool equals(const char *lhs, const char *rhs, size_t size) {
+    return T::equals(lhs + offset(size), rhs + offset(size));
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
-    return T::ThreeWayCompare(lhs + offset(size), rhs + offset(size));
+  static int three_way_compare(const char *lhs, const char *rhs, size_t size) {
+    return T::three_way_compare(lhs + offset(size), rhs + offset(size));
   }
 
-  static void SplatSet(char *dst, const unsigned char value, size_t size) {
-    return T::SplatSet(dst + offset(size), value);
+  static void splat_set(char *dst, const unsigned char value, size_t size) {
+    return T::splat_set(dst + offset(size), value);
   }
 
-  static size_t offset(size_t size) { return size - T::kSize; }
+  static size_t offset(size_t size) { return size - T::SIZE; }
 };
 
-// Perform the operation on the first and last 'T::kSize' bytes of the buffer.
+// Perform the operation on the first and last 'T::SIZE' bytes of the buffer.
 // This is useful for overlapping operations.
 //
 // e.g. with
 // [1234567812345678123]
 // [__XXXXXXXXXXXXXX___]
 // [__XXXXXXXX_________]
 // [________XXXXXXXX___]
 //
-// Precondition: `size >= T::kSize && size <= 2 x T::kSize`.
+// Precondition: `size >= T::SIZE && size <= 2 x T::SIZE`.
 template <typename T> struct HeadTail {
-  static void Copy(char *__restrict dst, const char *__restrict src,
+  static void copy(char *__restrict dst, const char *__restrict src,
                    size_t size) {
-    T::Copy(dst, src);
-    Tail<T>::Copy(dst, src, size);
+    T::copy(dst, src);
+    Tail<T>::copy(dst, src, size);
   }
 
-  static void Move(char *dst, const char *src, size_t size) {
+  static void move(char *dst, const char *src, size_t size) {
     const size_t offset = Tail<T>::offset(size);
-    const auto HeadValue = T::Load(src);
-    const auto TailValue = T::Load(src + offset);
-    T::Store(dst + offset, TailValue);
-    T::Store(dst, HeadValue);
+    const auto head_value = T::load(src);
+    const auto tail_value = T::load(src + offset);
+    T::store(dst + offset, tail_value);
+    T::store(dst, head_value);
   }
 
-  static bool Equals(const char *lhs, const char *rhs, size_t size) {
-    if (!T::Equals(lhs, rhs))
+  static bool equals(const char *lhs, const char *rhs, size_t size) {
+    if (!T::equals(lhs, rhs))
       return false;
-    return Tail<T>::Equals(lhs, rhs, size);
+    return Tail<T>::equals(lhs, rhs, size);
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
-    if (!T::Equals(lhs, rhs))
-      return T::ThreeWayCompare(lhs, rhs);
-    return Tail<T>::ThreeWayCompare(lhs, rhs, size);
+  static int three_way_compare(const char *lhs, const char *rhs, size_t size) {
+    if (!T::equals(lhs, rhs))
+      return T::three_way_compare(lhs, rhs);
+    return Tail<T>::three_way_compare(lhs, rhs, size);
   }
 
-  static void SplatSet(char *dst, const unsigned char value, size_t size) {
-    T::SplatSet(dst, value);
-    Tail<T>::SplatSet(dst, value, size);
+  static void splat_set(char *dst, const unsigned char value, size_t size) {
+    T::splat_set(dst, value);
+    Tail<T>::splat_set(dst, value, size);
   }
 };
 
 // Simple loop ending with a Tail operation.
 //
 // e.g. with
 // [12345678123456781234567812345678]
 // [__XXXXXXXXXXXXXXXXXXXXXXXXXXXX___]
 // [__XXXXXXXX_______________________]
 // [__________XXXXXXXX_______________]
 // [__________________XXXXXXXX_______]
 // [______________________XXXXXXXX___]
 //
 // Precondition:
-// - size >= T::kSize
+// - size >= T::SIZE
 template <typename T, typename TailT = T> struct Loop {
-  static_assert(T::kSize == TailT::kSize,
+  static_assert(T::SIZE == TailT::SIZE,
                 "Tail type must have the same size as T");
 
-  static void Copy(char *__restrict dst, const char *__restrict src,
+  static void copy(char *__restrict dst, const char *__restrict src,
                    size_t size) {
     size_t offset = 0;
     do {
-      T::Copy(dst + offset, src + offset);
-      offset += T::kSize;
-    } while (offset < size - T::kSize);
-    Tail<TailT>::Copy(dst, src, size);
+      T::copy(dst + offset, src + offset);
+      offset += T::SIZE;
+    } while (offset < size - T::SIZE);
+    Tail<TailT>::copy(dst, src, size);
   }
 
-  static bool Equals(const char *lhs, const char *rhs, size_t size) {
+  static bool equals(const char *lhs, const char *rhs, size_t size) {
     size_t offset = 0;
     do {
-      if (!T::Equals(lhs + offset, rhs + offset))
+      if (!T::equals(lhs + offset, rhs + offset))
         return false;
-      offset += T::kSize;
-    } while (offset < size - T::kSize);
-    return Tail<TailT>::Equals(lhs, rhs, size);
+      offset += T::SIZE;
+    } while (offset < size - T::SIZE);
+    return Tail<TailT>::equals(lhs, rhs, size);
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
+  static int three_way_compare(const char *lhs, const char *rhs, size_t size) {
     size_t offset = 0;
     do {
-      if (!T::Equals(lhs + offset, rhs + offset))
-        return T::ThreeWayCompare(lhs + offset, rhs + offset);
-      offset += T::kSize;
-    } while (offset < size - T::kSize);
-    return Tail<TailT>::ThreeWayCompare(lhs, rhs, size);
+      if (!T::equals(lhs + offset, rhs + offset))
+        return T::three_way_compare(lhs + offset, rhs + offset);
+      offset += T::SIZE;
+    } while (offset < size - T::SIZE);
+    return Tail<TailT>::three_way_compare(lhs, rhs, size);
   }
 
-  static void SplatSet(char *dst, const unsigned char value, size_t size) {
+  static void splat_set(char *dst, const unsigned char value, size_t size) {
     size_t offset = 0;
     do {
-      T::SplatSet(dst + offset, value);
-      offset += T::kSize;
-    } while (offset < size - T::kSize);
-    Tail<TailT>::SplatSet(dst, value, size);
+      T::splat_set(dst + offset, value);
+      offset += T::SIZE;
+    } while (offset < size - T::SIZE);
+    Tail<TailT>::splat_set(dst, value, size);
   }
 };
 
 enum class Arg { _1, _2, Dst = _1, Src = _2, Lhs = _1, Rhs = _2 };
 
 namespace internal {
 
-// Provides a specialized Bump function that adjusts pointers and size so first
+// Provides a specialized bump function that adjusts pointers and size so first
 // argument (resp. second argument) gets aligned to Alignment.
 // We make sure the compiler knows about the adjusted pointer alignment.
 template <Arg arg, size_t Alignment> struct AlignHelper {};
 
 template <size_t Alignment> struct AlignHelper<Arg::_1, Alignment> {
   template <typename T1, typename T2>
-  static void Bump(T1 *__restrict &p1ref, T2 *__restrict &p2ref, size_t &size) {
+  static void bump(T1 *__restrict &p1ref, T2 *__restrict &p2ref, size_t &size) {
     const intptr_t offset = offset_to_next_aligned<Alignment>(p1ref);
     p1ref += offset;
     p2ref += offset;
     size -= offset;
     p1ref = assume_aligned<Alignment>(p1ref);
   }
 };
 
 template <size_t Alignment> struct AlignHelper<Arg::_2, Alignment> {
   template <typename T1, typename T2>
-  static void Bump(T1 *__restrict &p1ref, T2 *__restrict &p2ref, size_t &size) {
+  static void bump(T1 *__restrict &p1ref, T2 *__restrict &p2ref, size_t &size) {
     const intptr_t offset = offset_to_next_aligned<Alignment>(p2ref);
     p1ref += offset;
     p2ref += offset;
     size -= offset;
     p2ref = assume_aligned<Alignment>(p2ref);
   }
 };
 
 } // namespace internal
 
 // An alignment operation that:
 // - executes the 'AlignmentT' operation
 // - bumps 'dst' or 'src' (resp. 'lhs' or 'rhs') pointers so that the selected
 //   pointer gets aligned, size is decreased accordingly.
 // - calls the 'NextT' operation.
 //
 // e.g. A 16-byte Destination Aligned 32-byte Loop Copy can be written as:
-// Copy<Align<_16, Arg::Dst>::Then<Loop<_32>>>(dst, src, count);
+// copy<Align<_16, Arg::Dst>::Then<Loop<_32>>>(dst, src, count);
 template <typename AlignmentT, Arg AlignOn = Arg::_1> struct Align {
 private:
-  static constexpr size_t Alignment = AlignmentT::kSize;
-  static_assert(Alignment > 1, "Alignment must be more than 1");
-  static_assert(is_power2(Alignment), "Alignment must be a power of 2");
+  static constexpr size_t ALIGNMENT = AlignmentT::SIZE;
+  static_assert(ALIGNMENT > 1, "Alignment must be more than 1");
+  static_assert(is_power2(ALIGNMENT), "Alignment must be a power of 2");
 
 public:
   template <typename NextT> struct Then {
-    static void Copy(char *__restrict dst, const char *__restrict src,
+    static void copy(char *__restrict dst, const char *__restrict src,
                      size_t size) {
-      AlignmentT::Copy(dst, src);
-      internal::AlignHelper<AlignOn, Alignment>::Bump(dst, src, size);
-      NextT::Copy(dst, src, size);
+      AlignmentT::copy(dst, src);
+      internal::AlignHelper<AlignOn, ALIGNMENT>::bump(dst, src, size);
+      NextT::copy(dst, src, size);
     }
 
-    static bool Equals(const char *lhs, const char *rhs, size_t size) {
-      if (!AlignmentT::Equals(lhs, rhs))
+    static bool equals(const char *lhs, const char *rhs, size_t size) {
+      if (!AlignmentT::equals(lhs, rhs))
         return false;
-      internal::AlignHelper<AlignOn, Alignment>::Bump(lhs, rhs, size);
-      return NextT::Equals(lhs, rhs, size);
+      internal::AlignHelper<AlignOn, ALIGNMENT>::bump(lhs, rhs, size);
+      return NextT::equals(lhs, rhs, size);
     }
 
-    static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
-      if (!AlignmentT::Equals(lhs, rhs))
-        return AlignmentT::ThreeWayCompare(lhs, rhs);
-      internal::AlignHelper<AlignOn, Alignment>::Bump(lhs, rhs, size);
-      return NextT::ThreeWayCompare(lhs, rhs, size);
+    static int three_way_compare(const char *lhs, const char *rhs,
+                                 size_t size) {
+      if (!AlignmentT::equals(lhs, rhs))
+        return AlignmentT::three_way_compare(lhs, rhs);
+      internal::AlignHelper<AlignOn, ALIGNMENT>::bump(lhs, rhs, size);
+      return NextT::three_way_compare(lhs, rhs, size);
     }
 
-    static void SplatSet(char *dst, const unsigned char value, size_t size) {
-      AlignmentT::SplatSet(dst, value);
+    static void splat_set(char *dst, const unsigned char value, size_t size) {
+      AlignmentT::splat_set(dst, value);
       char *dummy = nullptr;
-      internal::AlignHelper<Arg::_1, Alignment>::Bump(dst, dummy, size);
-      NextT::SplatSet(dst, value, size);
+      internal::AlignHelper<Arg::_1, ALIGNMENT>::bump(dst, dummy, size);
+      NextT::splat_set(dst, value, size);
     }
   };
 };
 
 // An operation that allows to skip the specified amount of bytes.
 template <ptrdiff_t Bytes> struct Skip {
   template <typename NextT> struct Then {
-    static void Copy(char *__restrict dst, const char *__restrict src,
+    static void copy(char *__restrict dst, const char *__restrict src,
                      size_t size) {
-      NextT::Copy(dst + Bytes, src + Bytes, size - Bytes);
+      NextT::copy(dst + Bytes, src + Bytes, size - Bytes);
     }
 
-    static void Copy(char *__restrict dst, const char *__restrict src) {
-      NextT::Copy(dst + Bytes, src + Bytes);
+    static void copy(char *__restrict dst, const char *__restrict src) {
+      NextT::copy(dst + Bytes, src + Bytes);
     }
 
-    static bool Equals(const char *lhs, const char *rhs, size_t size) {
-      return NextT::Equals(lhs + Bytes, rhs + Bytes, size - Bytes);
+    static bool equals(const char *lhs, const char *rhs, size_t size) {
+      return NextT::equals(lhs + Bytes, rhs + Bytes, size - Bytes);
     }
 
-    static bool Equals(const char *lhs, const char *rhs) {
-      return NextT::Equals(lhs + Bytes, rhs + Bytes);
+    static bool equals(const char *lhs, const char *rhs) {
+      return NextT::equals(lhs + Bytes, rhs + Bytes);
     }
 
-    static int ThreeWayCompare(const char *lhs, const char *rhs, size_t size) {
-      return NextT::ThreeWayCompare(lhs + Bytes, rhs + Bytes, size - Bytes);
+    static int three_way_compare(const char *lhs, const char *rhs,
+                                 size_t size) {
+      return NextT::three_way_compare(lhs + Bytes, rhs + Bytes, size - Bytes);
     }
 
-    static int ThreeWayCompare(const char *lhs, const char *rhs) {
-      return NextT::ThreeWayCompare(lhs + Bytes, rhs + Bytes);
+    static int three_way_compare(const char *lhs, const char *rhs) {
+      return NextT::three_way_compare(lhs + Bytes, rhs + Bytes);
     }
 
-    static void SplatSet(char *dst, const unsigned char value, size_t size) {
-      NextT::SplatSet(dst + Bytes, value, size - Bytes);
+    static void splat_set(char *dst, const unsigned char value, size_t size) {
+      NextT::splat_set(dst + Bytes, value, size - Bytes);
     }
 
-    static void SplatSet(char *dst, const unsigned char value) {
-      NextT::SplatSet(dst + Bytes, value);
+    static void splat_set(char *dst, const unsigned char value) {
+      NextT::splat_set(dst + Bytes, value);
     }
   };
 };
 
 // Fixed-size Builtin Operations
 // -----------------------------
 // Note: Do not use 'builtin' right now as it requires the implementation of the
 // `_inline` versions of all the builtins. Theoretically, Clang can still turn
 // them into calls to the C library leading to reentrancy problems.
 namespace builtin {
 
 #ifndef __has_builtin
 #define __has_builtin(x) 0 // Compatibility with non-clang compilers.
 #endif
 
 template <size_t Size> struct Builtin {
-  static constexpr size_t kSize = Size;
+  static constexpr size_t SIZE = Size;
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
+  static void copy(char *__restrict dst, const char *__restrict src) {
 #if LLVM_LIBC_HAVE_MEMORY_SANITIZER || LLVM_LIBC_HAVE_ADDRESS_SANITIZER
     ForLoopCopy(dst, src);
 #elif __has_builtin(__builtin_memcpy_inline)
     // __builtin_memcpy_inline guarantees to never call external functions.
     // Unfortunately it is not widely available.
-    __builtin_memcpy_inline(dst, src, kSize);
+    __builtin_memcpy_inline(dst, src, SIZE);
 #elif __has_builtin(__builtin_memcpy)
-    __builtin_memcpy(dst, src, kSize);
+    __builtin_memcpy(dst, src, SIZE);
 #else
     ForLoopCopy(dst, src);
 #endif
   }
 
-  static void Move(char *dst, const char *src) {
+  static void move(char *dst, const char *src) {
 #if LLVM_LIBC_HAVE_MEMORY_SANITIZER || LLVM_LIBC_HAVE_ADDRESS_SANITIZER
-    ForLoopMove(dst, src);
+    for_loop_move(dst, src);
 #elif __has_builtin(__builtin_memmove)
-    __builtin_memmove(dst, src, kSize);
+    __builtin_memmove(dst, src, SIZE);
 #else
-    ForLoopMove(dst, src);
+    for_loop_move(dst, src);
 #endif
   }
 
 #if __has_builtin(__builtin_memcmp_inline)
 #define LLVM_LIBC_MEMCMP __builtin_memcmp_inline
 #else
 #define LLVM_LIBC_MEMCMP __builtin_memcmp
 #endif
 
-  static bool Equals(const char *lhs, const char *rhs) {
-    return LLVM_LIBC_MEMCMP(lhs, rhs, kSize) == 0;
+  static bool equals(const char *lhs, const char *rhs) {
+    return LLVM_LIBC_MEMCMP(lhs, rhs, SIZE) == 0;
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
-    return LLVM_LIBC_MEMCMP(lhs, rhs, kSize);
+  static int three_way_compare(const char *lhs, const char *rhs) {
+    return LLVM_LIBC_MEMCMP(lhs, rhs, SIZE);
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    __builtin_memset(dst, value, kSize);
+  static void splat_set(char *dst, const unsigned char value) {
+    __builtin_memset(dst, value, SIZE);
   }
 
 private:
-  // Copies `kSize` bytes from `src` to `dst` using a for loop.
+  // Copies `SIZE` bytes from `src` to `dst` using a for loop.
   // This code requires the use of `-fno-builtin-memcpy` to prevent the compiler
   // from turning the for-loop back into `__builtin_memcpy`.
-  static void ForLoopCopy(char *__restrict dst, const char *__restrict src) {
-    for (size_t i = 0; i < kSize; ++i)
+  static void for_loop_copy(char *__restrict dst, const char *__restrict src) {
+    for (size_t i = 0; i < SIZE; ++i)
       dst[i] = src[i];
   }
 
-  static void ForLoopMove(char *dst, const char *src) {
-    for (size_t i = 0; i < kSize; ++i)
+  static void for_loop_move(char *dst, const char *src) {
+    for (size_t i = 0; i < SIZE; ++i)
       dst[i] = src[i];
   }
 };
 
 using _1 = Builtin<1>;
 using _2 = Builtin<2>;
 using _3 = Builtin<3>;
 using _4 = Builtin<4>;
 using _8 = Builtin<8>;
 using _16 = Builtin<16>;
 using _32 = Builtin<32>;
 using _64 = Builtin<64>;
 using _128 = Builtin<128>;
 
 } // namespace builtin
 
 // Fixed-size Scalar Operations
 // ----------------------------
 namespace scalar {
 
 // The Scalar type makes use of simple sized integers.
 template <typename T> struct Scalar {
-  static constexpr size_t kSize = sizeof(T);
+  static constexpr size_t SIZE = sizeof(T);
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
-    Store(dst, Load(src));
+  static void copy(char *__restrict dst, const char *__restrict src) {
+    store(dst, load(src));
   }
 
-  static void Move(char *dst, const char *src) { Store(dst, Load(src)); }
+  static void move(char *dst, const char *src) { store(dst, load(src)); }
 
-  static bool Equals(const char *lhs, const char *rhs) {
-    return Load(lhs) == Load(rhs);
+  static bool equals(const char *lhs, const char *rhs) {
+    return load(lhs) == load(rhs);
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
-    return ScalarThreeWayCompare(Load(lhs), Load(rhs));
+  static int three_way_compare(const char *lhs, const char *rhs) {
+    return scalar_three_way_compare(load(lhs), load(rhs));
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    Store(dst, GetSplattedValue(value));
+  static void splat_set(char *dst, const unsigned char value) {
+    store(dst, get_splatted_value(value));
   }
 
-  static int ScalarThreeWayCompare(T a, T b);
+  static int scalar_three_way_compare(T a, T b);
 
-  static T Load(const char *ptr) {
+  static T load(const char *ptr) {
     T value;
-    builtin::Builtin<kSize>::Copy(reinterpret_cast<char *>(&value), ptr);
+    builtin::Builtin<SIZE>::copy(reinterpret_cast<char *>(&value), ptr);
     return value;
   }
-
-  static void Store(char *ptr, T value) {
-    builtin::Builtin<kSize>::Copy(ptr, reinterpret_cast<const char *>(&value));
+  static void store(char *ptr, T value) {
+    builtin::Builtin<SIZE>::copy(ptr, reinterpret_cast<const char *>(&value));
   }
 
 private:
-  static T GetSplattedValue(const unsigned char value) {
+  static T get_splatted_value(const unsigned char value) {
     return T(~0) / T(0xFF) * T(value);
   }
 };
 
 template <>
-inline int Scalar<uint8_t>::ScalarThreeWayCompare(uint8_t a, uint8_t b) {
-  const int16_t la = Endian::ToBigEndian(a);
-  const int16_t lb = Endian::ToBigEndian(b);
+inline int Scalar<uint8_t>::scalar_three_way_compare(uint8_t a, uint8_t b) {
+  const int16_t la = Endian::to_big_endian(a);
+  const int16_t lb = Endian::to_big_endian(b);
   return la - lb;
 }
 template <>
-inline int Scalar<uint16_t>::ScalarThreeWayCompare(uint16_t a, uint16_t b) {
-  const int32_t la = Endian::ToBigEndian(a);
-  const int32_t lb = Endian::ToBigEndian(b);
+inline int Scalar<uint16_t>::scalar_three_way_compare(uint16_t a, uint16_t b) {
+  const int32_t la = Endian::to_big_endian(a);
+  const int32_t lb = Endian::to_big_endian(b);
   return la - lb;
 }
 template <>
-inline int Scalar<uint32_t>::ScalarThreeWayCompare(uint32_t a, uint32_t b) {
-  const uint32_t la = Endian::ToBigEndian(a);
-  const uint32_t lb = Endian::ToBigEndian(b);
+inline int Scalar<uint32_t>::scalar_three_way_compare(uint32_t a, uint32_t b) {
+  const uint32_t la = Endian::to_big_endian(a);
+  const uint32_t lb = Endian::to_big_endian(b);
   return la > lb ? 1 : la < lb ? -1 : 0;
 }
 template <>
-inline int Scalar<uint64_t>::ScalarThreeWayCompare(uint64_t a, uint64_t b) {
-  const uint64_t la = Endian::ToBigEndian(a);
-  const uint64_t lb = Endian::ToBigEndian(b);
+inline int Scalar<uint64_t>::scalar_three_way_compare(uint64_t a, uint64_t b) {
+  const uint64_t la = Endian::to_big_endian(a);
+  const uint64_t lb = Endian::to_big_endian(b);
   return la > lb ? 1 : la < lb ? -1 : 0;
 }
 
 using UINT8 = Scalar<uint8_t>;   // 1 Byte
 using UINT16 = Scalar<uint16_t>; // 2 Bytes
 using UINT32 = Scalar<uint32_t>; // 4 Bytes
 using UINT64 = Scalar<uint64_t>; // 8 Bytes
 

libc/src/string/memory_utils/elements_aarch64.h

 #ifdef __ARM_NEON
 #include <arm_neon.h>
 #endif
 
 namespace __llvm_libc {
 namespace aarch64_memset {
 #ifdef __ARM_NEON
 struct Splat8 {
-  static constexpr size_t kSize = 8;
-  static void SplatSet(char *dst, const unsigned char value) {
+  static constexpr size_t SIZE = 8;
+  static void splat_set(char *dst, const unsigned char value) {
     vst1_u8((uint8_t *)dst, vdup_n_u8(value));
   }
 };
 
 struct Splat16 {
-  static constexpr size_t kSize = 16;
-  static void SplatSet(char *dst, const unsigned char value) {
+  static constexpr size_t SIZE = 16;
+  static void splat_set(char *dst, const unsigned char value) {
     vst1q_u8((uint8_t *)dst, vdupq_n_u8(value));
   }
 };
 
 using _8 = Splat8;
 using _16 = Splat16;
 #else
 using _8 = __llvm_libc::scalar::_8;
 using _16 = Repeated<_8, 2>;
 #endif // __ARM_NEON
 
 using _1 = __llvm_libc::scalar::_1;
 using _2 = __llvm_libc::scalar::_2;
 using _3 = __llvm_libc::scalar::_3;
 using _4 = __llvm_libc::scalar::_4;
 using _32 = Chained<_16, _16>;
 using _64 = Chained<_32, _32>;
 
 struct ZVA {
-  static constexpr size_t kSize = 64;
-  static void SplatSet(char *dst, const unsigned char value) {
+  static constexpr size_t SIZE = 64;
+  static void splat_set(char *dst, const unsigned char value) {
     asm("dc zva, %[dst]" : : [dst] "r"(dst) : "memory");
   }
 };
 
 inline static bool AArch64ZVA(char *dst, size_t count) {
   uint64_t zva_val;
   asm("mrs %[zva_val], dczid_el0" : [zva_val] "=r"(zva_val));
   if ((zva_val & 31) != 4)
     return false;
-  SplatSet<Align<_64, Arg::_1>::Then<Loop<ZVA, _64>>>(dst, 0, count);
+  splat_set<Align<_64, Arg::_1>::Then<Loop<ZVA, _64>>>(dst, 0, count);
   return true;
 }
 
 } // namespace aarch64_memset
 
 namespace aarch64 {
 
 using _1 = __llvm_libc::scalar::_1;
 using _2 = __llvm_libc::scalar::_2;
 using _3 = __llvm_libc::scalar::_3;
 using _4 = __llvm_libc::scalar::_4;
 using _8 = __llvm_libc::scalar::_8;
 using _16 = __llvm_libc::scalar::_16;
 
 #ifdef __ARM_NEON
 struct N32 {
-  static constexpr size_t kSize = 32;
-  static bool Equals(const char *lhs, const char *rhs) {
+  static constexpr size_t SIZE = 32;
+  static bool equals(const char *lhs, const char *rhs) {
     uint8x16_t l_0 = vld1q_u8((const uint8_t *)lhs);
     uint8x16_t r_0 = vld1q_u8((const uint8_t *)rhs);
     uint8x16_t l_1 = vld1q_u8((const uint8_t *)(lhs + 16));
     uint8x16_t r_1 = vld1q_u8((const uint8_t *)(rhs + 16));
     uint8x16_t temp = vpmaxq_u8(veorq_u8(l_0, r_0), veorq_u8(l_1, r_1));
     uint64_t res =
         vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(temp, temp)), 0);
     return res == 0;
   }
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
+  static int three_way_compare(const char *lhs, const char *rhs) {
     uint8x16_t l_0 = vld1q_u8((const uint8_t *)lhs);
     uint8x16_t r_0 = vld1q_u8((const uint8_t *)rhs);
     uint8x16_t l_1 = vld1q_u8((const uint8_t *)(lhs + 16));
     uint8x16_t r_1 = vld1q_u8((const uint8_t *)(rhs + 16));
     uint8x16_t temp = vpmaxq_u8(veorq_u8(l_0, r_0), veorq_u8(l_1, r_1));
     uint64_t res =
         vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(temp, temp)), 0);
     if (res == 0)
       return 0;
     size_t index = (__builtin_ctzl(res) >> 3) << 2;
     uint32_t l = *((const uint32_t *)(lhs + index));
     uint32_t r = *((const uint32_t *)(rhs + index));
-    return __llvm_libc::scalar::_4::ScalarThreeWayCompare(l, r);
+    return __llvm_libc::scalar::_4::scalar_three_way_compare(l, r);
   }
 };
 
 using _32 = N32;
 using _64 = Repeated<_32, 2>;
 #else
 using _32 = __llvm_libc::scalar::_32;
 using _64 = __llvm_libc::scalar::_64;
 #endif // __ARM_NEON
 
 } // namespace aarch64
 } // namespace __llvm_libc
 
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_AARCH64_H

libc/src/string/memory_utils/elements_x86.h

 // Fixed-size Vector Operations
 // ----------------------------
 
 namespace __llvm_libc {
 namespace x86 {
 
 #ifdef __SSE2__
 template <typename Base> struct Vector : public Base {
-  static void Copy(char *__restrict dst, const char *__restrict src) {
-    Base::Store(dst, Base::Load(src));
+  static void copy(char *__restrict dst, const char *__restrict src) {
+    Base::store(dst, Base::load(src));
   }
 
-  static void Move(char *dst, const char *src) {
-    Base::Store(dst, Base::Load(src));
+  static void move(char *dst, const char *src) {
+    Base::store(dst, Base::load(src));
   }
 
-  static bool Equals(const char *a, const char *b) {
-    return Base::NotEqualMask(Base::Load(a), Base::Load(b)) == 0;
+  static bool equals(const char *a, const char *b) {
+    return Base::not_equal_mask(Base::load(a), Base::load(b)) == 0;
   }
 
-  static int ThreeWayCompare(const char *a, const char *b) {
-    const auto mask = Base::NotEqualMask(Base::Load(a), Base::Load(b));
+  static int three_way_compare(const char *a, const char *b) {
+    const auto mask = Base::not_equal_mask(Base::load(a), Base::load(b));
     if (!mask)
       return 0;
-    return CharDiff(a, b, mask);
+    return char_diff(a, b, mask);
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    Base::Store(dst, Base::GetSplattedValue(value));
+  static void splat_set(char *dst, const unsigned char value) {
+    Base::store(dst, Base::get_splatted_value(value));
   }
 
-  static int CharDiff(const char *a, const char *b, uint64_t mask) {
+  static int char_diff(const char *a, const char *b, uint64_t mask) {
     const size_t diff_index = __builtin_ctzll(mask);
     const int ca = (unsigned char)a[diff_index];
     const int cb = (unsigned char)b[diff_index];
     return ca - cb;
   }
 };
 
 struct M128 {
-  static constexpr size_t kSize = 16;
-  using T = char __attribute__((__vector_size__(kSize)));
+  static constexpr size_t SIZE = 16;
+  using T = char __attribute__((__vector_size__(SIZE)));
   static uint16_t mask(T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm_movemask_epi8(value);
   }
-  static uint16_t NotEqualMask(T a, T b) { return mask(a != b); }
-  static T Load(const char *ptr) {
+  static uint16_t not_equal_mask(T a, T b) { return mask(a != b); }
+  static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm_loadu_si128(reinterpret_cast<__m128i_u const *>(ptr));
   }
-  static void Store(char *ptr, T value) {
+  static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm_storeu_si128(reinterpret_cast<__m128i_u *>(ptr), value);
   }
-  static T GetSplattedValue(const char v) {
+  static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }
 };
 
 using Vector128 = Vector<M128>; // 16 Bytes
 
 #ifdef __AVX2__
 struct M256 {
-  static constexpr size_t kSize = 32;
-  using T = char __attribute__((__vector_size__(kSize)));
+  static constexpr size_t SIZE = 32;
+  using T = char __attribute__((__vector_size__(SIZE)));
   static uint32_t mask(T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm256_movemask_epi8(value);
   }
-  static uint32_t NotEqualMask(T a, T b) { return mask(a != b); }
-  static T Load(const char *ptr) {
+  static uint32_t not_equal_mask(T a, T b) { return mask(a != b); }
+  static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm256_loadu_si256(reinterpret_cast<__m256i const *>(ptr));
   }
-  static void Store(char *ptr, T value) {
+  static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr), value);
   }
-  static T GetSplattedValue(const char v) {
+  static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }
 };
 
 using Vector256 = Vector<M256>; // 32 Bytes
 
 #if defined(__AVX512F__) and defined(__AVX512BW__)
 struct M512 {
-  static constexpr size_t kSize = 64;
-  using T = char __attribute__((__vector_size__(kSize)));
-  static uint64_t NotEqualMask(T a, T b) {
+  static constexpr size_t SIZE = 64;
+  using T = char __attribute__((__vector_size__(SIZE)));
+  static uint64_t not_equal_mask(T a, T b) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm512_cmpneq_epi8_mask(a, b);
   }
-  static T Load(const char *ptr) {
+  static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm512_loadu_epi8(ptr);
   }
-  static void Store(char *ptr, T value) {
+  static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
     return _mm512_storeu_epi8(ptr, value);
   }
-  static T GetSplattedValue(const char v) {
+  static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }
 };
 using Vector512 = Vector<M512>;

 #else
 using _16 = __llvm_libc::Repeated<_8, 2>;
 using _32 = __llvm_libc::Repeated<_8, 4>;
 using _64 = __llvm_libc::Repeated<_8, 8>;
 using _128 = __llvm_libc::Repeated<_8, 16>;
 #endif
 
 struct Accelerator {
-  static void Copy(char *dst, const char *src, size_t count) {
+  static void copy(char *dst, const char *src, size_t count) {
     asm volatile("rep movsb" : "+D"(dst), "+S"(src), "+c"(count) : : "memory");
   }
 };
 
 } // namespace x86
 } // namespace __llvm_libc
 
 #endif // defined(LLVM_LIBC_ARCH_X86)
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_X86_H

libc/src/string/memory_utils/memcmp_implementations.h

 #if defined(LLVM_LIBC_ARCH_X86)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_X86
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::x86;
   if (count == 0)
     return 0;
   if (count == 1)
-    return ThreeWayCompare<_1>(lhs, rhs);
+    return three_way_compare<_1>(lhs, rhs);
   if (count == 2)
-    return ThreeWayCompare<_2>(lhs, rhs);
+    return three_way_compare<_2>(lhs, rhs);
   if (count == 3)
-    return ThreeWayCompare<_3>(lhs, rhs);
+    return three_way_compare<_3>(lhs, rhs);
   if (count <= 8)
-    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_4>>(lhs, rhs, count);
   if (count <= 16)
-    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_8>>(lhs, rhs, count);
   if (count <= 32)
-    return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_16>>(lhs, rhs, count);
   if (count <= 64)
-    return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_32>>(lhs, rhs, count);
   if (count <= 128)
-    return ThreeWayCompare<HeadTail<_64>>(lhs, rhs, count);
-  return ThreeWayCompare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_64>>(lhs, rhs, count);
+  return three_way_compare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_AARCH64
   /////////////////////////////////////////////////////////////////////////////
   using namespace ::__llvm_libc::aarch64;
   if (count == 0) // [0, 0]
     return 0;
   if (count == 1) // [1, 1]
-    return ThreeWayCompare<_1>(lhs, rhs);
+    return three_way_compare<_1>(lhs, rhs);
   if (count == 2) // [2, 2]
-    return ThreeWayCompare<_2>(lhs, rhs);
+    return three_way_compare<_2>(lhs, rhs);
   if (count == 3) // [3, 3]
-    return ThreeWayCompare<_3>(lhs, rhs);
+    return three_way_compare<_3>(lhs, rhs);
   if (count < 8) // [4, 7]
-    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_4>>(lhs, rhs, count);
   if (count < 16) // [8, 15]
-    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_8>>(lhs, rhs, count);
   if (unlikely(count >= 128)) // [128, ∞]
-    return ThreeWayCompare<Align<_16>::Then<Loop<_32>>>(lhs, rhs, count);
-  if (!Equals<_16>(lhs, rhs)) // [16, 16]
-    return ThreeWayCompare<_16>(lhs, rhs);
+    return three_way_compare<Align<_16>::Then<Loop<_32>>>(lhs, rhs, count);
+  if (!equals<_16>(lhs, rhs)) // [16, 16]
+    return three_way_compare<_16>(lhs, rhs);
   if (count < 32) // [17, 31]
-    return ThreeWayCompare<Tail<_16>>(lhs, rhs, count);
-  if (!Equals<Skip<16>::Then<_16>>(lhs, rhs)) // [32, 32]
-    return ThreeWayCompare<Skip<16>::Then<_16>>(lhs, rhs);
+    return three_way_compare<Tail<_16>>(lhs, rhs, count);
+  if (!equals<Skip<16>::Then<_16>>(lhs, rhs)) // [32, 32]
+    return three_way_compare<Skip<16>::Then<_16>>(lhs, rhs);
   if (count < 64) // [33, 63]
-    return ThreeWayCompare<Tail<_32>>(lhs, rhs, count);
+    return three_way_compare<Tail<_32>>(lhs, rhs, count);
   // [64, 127]
-  return ThreeWayCompare<Skip<32>::Then<Loop<_16>>>(lhs, rhs, count);
+  return three_way_compare<Skip<32>::Then<Loop<_16>>>(lhs, rhs, count);
 #else
   /////////////////////////////////////////////////////////////////////////////
   // Default
   /////////////////////////////////////////////////////////////////////////////
   using namespace ::__llvm_libc::scalar;
 
   if (count == 0)
     return 0;
   if (count == 1)
-    return ThreeWayCompare<_1>(lhs, rhs);
+    return three_way_compare<_1>(lhs, rhs);
   if (count == 2)
-    return ThreeWayCompare<_2>(lhs, rhs);
+    return three_way_compare<_2>(lhs, rhs);
   if (count == 3)
-    return ThreeWayCompare<_3>(lhs, rhs);
+    return three_way_compare<_3>(lhs, rhs);
   if (count <= 8)
-    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_4>>(lhs, rhs, count);
   if (count <= 16)
-    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_8>>(lhs, rhs, count);
   if (count <= 32)
-    return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_16>>(lhs, rhs, count);
   if (count <= 64)
-    return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_32>>(lhs, rhs, count);
   if (count <= 128)
-    return ThreeWayCompare<HeadTail<_64>>(lhs, rhs, count);
-  return ThreeWayCompare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
+    return three_way_compare<HeadTail<_64>>(lhs, rhs, count);
+  return three_way_compare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
 #endif
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcpy_implementations.h

static inline void inline_memcpy(char *__restrict dst,
                                  const char *__restrict src, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_X86
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::x86;
 
   // Whether to use only rep;movsb.
-  constexpr bool kUseOnlyRepMovsb =
+  constexpr bool USE_ONLY_REP_MOVSB =
       LLVM_LIBC_IS_DEFINED(LLVM_LIBC_MEMCPY_X86_USE_ONLY_REPMOVSB);
 
   // kRepMovsBSize == -1 : Only CopyAligned is used.
   // kRepMovsBSize ==  0 : Only RepMovsb is used.
   // else CopyAligned is used up to kRepMovsBSize and then RepMovsb.
-  constexpr size_t kRepMovsBSize =
+  constexpr size_t REP_MOVS_B_SIZE =
 #if defined(LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE)
       LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE;
 #else
       -1;
 #endif // LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE
 
   // Whether target supports AVX instructions.
-  constexpr bool kHasAvx = LLVM_LIBC_IS_DEFINED(__AVX__);
+  constexpr bool HAS_AVX = LLVM_LIBC_IS_DEFINED(__AVX__);
 
 #if defined(__AVX__)
   using LoopBlockSize = _64;
 #else
   using LoopBlockSize = _32;
 #endif
 
-  if (kUseOnlyRepMovsb)
-    return Copy<Accelerator>(dst, src, count);
+  if (USE_ONLY_REP_MOVSB)
+    return copy<Accelerator>(dst, src, count);
 
   if (count == 0)
     return;
   if (count == 1)
-    return Copy<_1>(dst, src);
+    return copy<_1>(dst, src);
   if (count == 2)
-    return Copy<_2>(dst, src);
+    return copy<_2>(dst, src);
   if (count == 3)
-    return Copy<_3>(dst, src);
+    return copy<_3>(dst, src);
   if (count == 4)
-    return Copy<_4>(dst, src);
+    return copy<_4>(dst, src);
   if (count < 8)
-    return Copy<HeadTail<_4>>(dst, src, count);
+    return copy<HeadTail<_4>>(dst, src, count);
   if (count < 16)
-    return Copy<HeadTail<_8>>(dst, src, count);
+    return copy<HeadTail<_8>>(dst, src, count);
   if (count < 32)
-    return Copy<HeadTail<_16>>(dst, src, count);
+    return copy<HeadTail<_16>>(dst, src, count);
   if (count < 64)
-    return Copy<HeadTail<_32>>(dst, src, count);
+    return copy<HeadTail<_32>>(dst, src, count);
   if (count < 128)
-    return Copy<HeadTail<_64>>(dst, src, count);
-  if (kHasAvx && count < 256)
-    return Copy<HeadTail<_128>>(dst, src, count);
-  if (count <= kRepMovsBSize)
-    return Copy<Align<_32, Arg::Dst>::Then<Loop<LoopBlockSize>>>(dst, src,
+    return copy<HeadTail<_64>>(dst, src, count);
+  if (HAS_AVX && count < 256)
+    return copy<HeadTail<_128>>(dst, src, count);
+  if (count <= REP_MOVS_B_SIZE)
+    return copy<Align<_32, Arg::Dst>::Then<Loop<LoopBlockSize>>>(dst, src,
                                                                  count);
-  return Copy<Accelerator>(dst, src, count);
+  return copy<Accelerator>(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_AARCH64
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::scalar;
   if (count == 0)
     return;
   if (count == 1)
-    return Copy<_1>(dst, src);
+    return copy<_1>(dst, src);
   if (count == 2)
-    return Copy<_2>(dst, src);
+    return copy<_2>(dst, src);
   if (count == 3)
-    return Copy<_3>(dst, src);
+    return copy<_3>(dst, src);
   if (count == 4)
-    return Copy<_4>(dst, src);
+    return copy<_4>(dst, src);
   if (count < 8)
-    return Copy<HeadTail<_4>>(dst, src, count);
+    return copy<HeadTail<_4>>(dst, src, count);
   if (count < 16)
-    return Copy<HeadTail<_8>>(dst, src, count);
+    return copy<HeadTail<_8>>(dst, src, count);
   if (count < 32)
-    return Copy<HeadTail<_16>>(dst, src, count);
+    return copy<HeadTail<_16>>(dst, src, count);
   if (count < 64)
-    return Copy<HeadTail<_32>>(dst, src, count);
+    return copy<HeadTail<_32>>(dst, src, count);
   if (count < 128)
-    return Copy<HeadTail<_64>>(dst, src, count);
-  return Copy<Align<_16, Arg::Src>::Then<Loop<_64>>>(dst, src, count);
+    return copy<HeadTail<_64>>(dst, src, count);
+  return copy<Align<_16, Arg::Src>::Then<Loop<_64>>>(dst, src, count);
 #else
   /////////////////////////////////////////////////////////////////////////////
   // Default
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::scalar;
   if (count == 0)
     return;
   if (count == 1)
-    return Copy<_1>(dst, src);
+    return copy<_1>(dst, src);
   if (count == 2)
-    return Copy<_2>(dst, src);
+    return copy<_2>(dst, src);
   if (count == 3)
-    return Copy<_3>(dst, src);
+    return copy<_3>(dst, src);
   if (count == 4)
-    return Copy<_4>(dst, src);
+    return copy<_4>(dst, src);
   if (count < 8)
-    return Copy<HeadTail<_4>>(dst, src, count);
+    return copy<HeadTail<_4>>(dst, src, count);
   if (count < 16)
-    return Copy<HeadTail<_8>>(dst, src, count);
+    return copy<HeadTail<_8>>(dst, src, count);
   if (count < 32)
-    return Copy<HeadTail<_16>>(dst, src, count);
+    return copy<HeadTail<_16>>(dst, src, count);
   if (count < 64)
-    return Copy<HeadTail<_32>>(dst, src, count);
+    return copy<HeadTail<_32>>(dst, src, count);
   if (count < 128)
-    return Copy<HeadTail<_64>>(dst, src, count);
-  return Copy<Align<_32, Arg::Src>::Then<Loop<_32>>>(dst, src, count);
+    return copy<HeadTail<_64>>(dst, src, count);
+  return copy<Align<_32, Arg::Src>::Then<Loop<_32>>>(dst, src, count);
 #endif
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memset_implementations.h

 //  - The number of conditionals for sizes <=128 (~90% of memset calls are for
 //    such sizes).
 //
 // For the range 64-128:
 //  - SetBlockOverlap<64> uses no conditionals but always writes 128 Bytes this
 //  is wasteful near 65 but efficient toward 128.
 //  - SetAlignedBlocks<32> would consume between 3 and 4 conditionals and write
 //  96 or 128 Bytes.
-//  - Another approach could be to use an hybrid approach Copy<64>+Overlap<32>
-//  for 65-96 and Copy<96>+Overlap<32> for 97-128
+//  - Another approach could be to use an hybrid approach copy<64>+Overlap<32>
+//  for 65-96 and copy<96>+Overlap<32> for 97-128
 //
 // Benchmarks showed that redundant writes were cheap (for Intel X86) but
 // conditional were expensive, even on processor that do not support writing 64B
 // at a time (pre-AVX512F). We also want to favor short functions that allow
 // more hot code to fit in the iL1 cache.
 //
 // Above 128 we have to use conditionals since we don't know the upper bound in
 // advance. SetAlignedBlocks<64> may waste up to 63 Bytes, SetAlignedBlocks<32>
 // may waste up to 31 Bytes. Benchmarks showed that SetAlignedBlocks<64> was not
 // superior for sizes that mattered.
 inline static void inline_memset(char *dst, unsigned char value, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_X86
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::x86;
   if (count == 0)
     return;
   if (count == 1)
-    return SplatSet<_1>(dst, value);
+    return splat_set<_1>(dst, value);
   if (count == 2)
-    return SplatSet<_2>(dst, value);
+    return splat_set<_2>(dst, value);
   if (count == 3)
-    return SplatSet<_3>(dst, value);
+    return splat_set<_3>(dst, value);
   if (count <= 8)
-    return SplatSet<HeadTail<_4>>(dst, value, count);
+    return splat_set<HeadTail<_4>>(dst, value, count);
   if (count <= 16)
-    return SplatSet<HeadTail<_8>>(dst, value, count);
+    return splat_set<HeadTail<_8>>(dst, value, count);
   if (count <= 32)
-    return SplatSet<HeadTail<_16>>(dst, value, count);
+    return splat_set<HeadTail<_16>>(dst, value, count);
   if (count <= 64)
-    return SplatSet<HeadTail<_32>>(dst, value, count);
+    return splat_set<HeadTail<_32>>(dst, value, count);
   if (count <= 128)
-    return SplatSet<HeadTail<_64>>(dst, value, count);
-  return SplatSet<Align<_32, Arg::Dst>::Then<Loop<_32>>>(dst, value, count);
+    return splat_set<HeadTail<_64>>(dst, value, count);
+  return splat_set<Align<_32, Arg::Dst>::Then<Loop<_32>>>(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   /////////////////////////////////////////////////////////////////////////////
   // LLVM_LIBC_ARCH_AARCH64
   /////////////////////////////////////////////////////////////////////////////
   using namespace __llvm_libc::aarch64_memset;
   if (count == 0)
     return;
   if (count <= 3) {
-    SplatSet<_1>(dst, value);
+    splat_set<_1>(dst, value);
     if (count > 1)
-      SplatSet<Tail<_2>>(dst, value, count);
+      splat_set<Tail<_2>>(dst, value, count);
     return;
   }
   if (count <= 8)
-    return SplatSet<HeadTail<_4>>(dst, value, count);
+    return splat_set<HeadTail<_4>>(dst, value, count);
   if (count <= 16)
-    return SplatSet<HeadTail<_8>>(dst, value, count);
+    return splat_set<HeadTail<_8>>(dst, value, count);
   if (count <= 32)
-    return SplatSet<HeadTail<_16>>(dst, value, count);
+    return splat_set<HeadTail<_16>>(dst, value, count);
   if (count <= 96) {
-    SplatSet<_32>(dst, value);
+    splat_set<_32>(dst, value);
     if (count <= 64)
-      return SplatSet<Tail<_32>>(dst, value, count);
-    SplatSet<Skip<32>::Then<_32>>(dst, value);
-    SplatSet<Tail<_32>>(dst, value, count);
+      return splat_set<Tail<_32>>(dst, value, count);
+    splat_set<Skip<32>::Then<_32>>(dst, value);
+    splat_set<Tail<_32>>(dst, value, count);
     return;
   }
   if (count < 448 || value != 0 || !AArch64ZVA(dst, count))
-    return SplatSet<Align<_16, Arg::_1>::Then<Loop<_64>>>(dst, value, count);
+    return splat_set<Align<_16, Arg::_1>::Then<Loop<_64>>>(dst, value, count);
 #else
   /////////////////////////////////////////////////////////////////////////////
   // Default
   /////////////////////////////////////////////////////////////////////////////
   using namespace ::__llvm_libc::scalar;
 
   if (count == 0)
     return;
   if (count == 1)
-    return SplatSet<_1>(dst, value);
+    return splat_set<_1>(dst, value);
   if (count == 2)
-    return SplatSet<_2>(dst, value);
+    return splat_set<_2>(dst, value);
   if (count == 3)
-    return SplatSet<_3>(dst, value);
+    return splat_set<_3>(dst, value);
   if (count <= 8)
-    return SplatSet<HeadTail<_4>>(dst, value, count);
+    return splat_set<HeadTail<_4>>(dst, value, count);
   if (count <= 16)
-    return SplatSet<HeadTail<_8>>(dst, value, count);
+    return splat_set<HeadTail<_8>>(dst, value, count);
   if (count <= 32)
-    return SplatSet<HeadTail<_16>>(dst, value, count);
+    return splat_set<HeadTail<_16>>(dst, value, count);
   if (count <= 64)
-    return SplatSet<HeadTail<_32>>(dst, value, count);
+    return splat_set<HeadTail<_32>>(dst, value, count);
   if (count <= 128)
-    return SplatSet<HeadTail<_64>>(dst, value, count);
-  return SplatSet<Align<_32, Arg::Dst>::Then<Loop<_32>>>(dst, value, count);
+    return splat_set<HeadTail<_64>>(dst, value, count);
+  return splat_set<Align<_32, Arg::Dst>::Then<Loop<_32>>>(dst, value, count);
 #endif
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H

libc/src/string/strcat.cpp

 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strcat,
                    (char *__restrict dest, const char *__restrict src)) {
-  size_t destLength = internal::string_length(dest);
-  size_t srcLength = internal::string_length(src);
-  __llvm_libc::strcpy(dest + destLength, src);
-  dest[destLength + srcLength] = '\0';
+  size_t dest_length = internal::string_length(dest);
+  size_t src_length = internal::string_length(src);
+  __llvm_libc::strcpy(dest + dest_length, src);
+  dest[dest_length + src_length] = '\0';
   return dest;
 }
 
 } // namespace __llvm_libc

libc/src/string/strncat.cpp

 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strncat,
                    (char *__restrict dest, const char *__restrict src,
                     size_t count)) {
-  size_t srcLength = internal::string_length(src);
-  size_t copyAmount = srcLength > count ? count : srcLength;
-  size_t destLength = internal::string_length(dest);
-  __llvm_libc::strncpy(dest + destLength, src, copyAmount);
-  dest[destLength + copyAmount] = '\0';
+  size_t src_length = internal::string_length(src);
+  size_t copy_amount = src_length > count ? count : src_length;
+  size_t dest_length = internal::string_length(dest);
+  __llvm_libc::strncpy(dest + dest_length, src, copy_amount);
+  dest[dest_length + copy_amount] = '\0';
   return dest;
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/Thread.h

 #include "thread_start_args.h"
 
 #include <stdatomic.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 struct ThreadParams {
-  static constexpr uintptr_t DefaultStackSize = 1 << 16; // 64 KB
-  static constexpr uint32_t ClearTIDValue = 0xABCD1234;
+  static constexpr uintptr_t DEFAULT_STACK_SIZE = 1 << 16; // 64 KB
+  static constexpr uint32_t CLEAR_TID_VALUE = 0xABCD1234;
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_LINUX_THREAD_UTILS_H

libc/src/threads/linux/thrd_create.cpp

unsigned clone_flags =
       | CLONE_SYSVSEM // Share a single list of System V semaphore adjustment
                       // values
       | CLONE_PARENT_SETTID   // Set child thread ID in |ptid| of the parent.
       | CLONE_CHILD_CLEARTID; // Let the kernel clear the tid address and futex
                               // wake the joining thread.
   // TODO: Add the CLONE_SETTLS flag and setup the TLS area correctly when
   // making the clone syscall.
 
-  void *stack = __llvm_libc::mmap(nullptr, ThreadParams::DefaultStackSize,
+  void *stack = __llvm_libc::mmap(nullptr, ThreadParams::DEFAULT_STACK_SIZE,
                                   PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   if (stack == MAP_FAILED)
     return llvmlibc_errno == ENOMEM ? thrd_nomem : thrd_error;
 
   thread->__stack = stack;
-  thread->__stack_size = ThreadParams::DefaultStackSize;
+  thread->__stack_size = ThreadParams::DEFAULT_STACK_SIZE;
   thread->__retval = -1;
   FutexWord *clear_tid_address =
       reinterpret_cast<FutexWord *>(thread->__clear_tid);
-  *clear_tid_address = ThreadParams::ClearTIDValue;
+  *clear_tid_address = ThreadParams::CLEAR_TID_VALUE;
 
   // When the new thread is spawned by the kernel, the new thread gets the
   // stack we pass to the clone syscall. However, this stack is empty and does
   // not have any local vars present in this function. Hence, one cannot
   // pass arguments to the thread start function, or use any local vars from
   // here. So, we pack them into the new stack from where the thread can sniff
   // them out.
   uintptr_t adjusted_stack = reinterpret_cast<uintptr_t>(stack) +
-                             ThreadParams::DefaultStackSize - sizeof(StartArgs);
+                             ThreadParams::DEFAULT_STACK_SIZE -
+                             sizeof(StartArgs);
   StartArgs *start_args = reinterpret_cast<StartArgs *>(adjusted_stack);
   start_args->thread = thread;
   start_args->func = func;
   start_args->arg = arg;
 
   // TODO: The arguments to the clone syscall below is correct for x86_64
   // but it might differ for other architectures. So, make this call
   // architecture independent. May be implement a glibc like wrapper for clone
   // and use it here.
   long register clone_result asm("rax");
-  clone_result =
-      __llvm_libc::syscall(SYS_clone, clone_flags, adjusted_stack,
+  clone_result = __llvm_libc::syscall(SYS_clone, clone_flags, adjusted_stack,
                                       &thread->__tid, clear_tid_address, 0);
 
   if (clone_result == 0) {
     start_thread();
   } else if (clone_result < 0) {
     __llvm_libc::munmap(thread->__stack, thread->__stack_size);
     int error_val = -clone_result;
     return error_val == ENOMEM ? thrd_nomem : thrd_error;
   }
 
   return thrd_success;
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/thrd_join.cpp

LLVM_LIBC_FUNCTION(int, thrd_join, (thrd_t * thread, int *retval)) {
 
   // The kernel should set the value at the clear tid address to zero.
   // If not, it is a spurious wake and we should continue to wait on
   // the futex.
   while (atomic_load(clear_tid_address) != 0) {
     // We cannot do a FUTEX_WAIT_PRIVATE here as the kernel does a
     // FUTEX_WAKE and not a FUTEX_WAKE_PRIVATE.
     __llvm_libc::syscall(SYS_futex, clear_tid_address, FUTEX_WAIT,
-                         ThreadParams::ClearTIDValue, nullptr);
+                         ThreadParams::CLEAR_TID_VALUE, nullptr);
   }
 
   *retval = thread->__retval;
 
   if (__llvm_libc::munmap(thread->__stack, thread->__stack_size) == -1)
     return thrd_error;
 
   return thrd_success;
 }
 
 } // namespace __llvm_libc

libc/src/time/asctime.cpp

 #include "src/__support/common.h"
 #include "src/time/time_utils.h"
 
 namespace __llvm_libc {
 
 using __llvm_libc::time_utils::TimeConstants;
 
 LLVM_LIBC_FUNCTION(char *, asctime, (const struct tm *timeptr)) {
-  static char buffer[TimeConstants::AsctimeBufferSize];
-  return time_utils::asctime(timeptr, buffer, TimeConstants::AsctimeMaxBytes);
+  static char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
+  return time_utils::asctime(timeptr, buffer, TimeConstants::ASCTIME_MAX_BYTES);
 }
 
 } // namespace __llvm_libc

libc/src/time/asctime_r.cpp

 #include "src/time/time_utils.h"
 
 namespace __llvm_libc {
 
 using __llvm_libc::time_utils::TimeConstants;
 
 LLVM_LIBC_FUNCTION(char *, asctime_r,
                    (const struct tm *timeptr, char *buffer)) {
-  return time_utils::asctime(timeptr, buffer, TimeConstants::AsctimeMaxBytes);
+  return time_utils::asctime(timeptr, buffer, TimeConstants::ASCTIME_MAX_BYTES);
 }
 
 } // namespace __llvm_libc

libc/src/time/mktime.cpp

 #include "src/time/time_utils.h"
 
 #include <limits.h>
 
 namespace __llvm_libc {
 
 using __llvm_libc::time_utils::TimeConstants;
 
-static constexpr int NonLeapYearDaysInMonth[] = {31, 28, 31, 30, 31, 30,
+static constexpr int NON_LEAP_YEAR_DAYS_IN_MONTH[] = {31, 28, 31, 30, 31, 30,
                                                       31, 31, 30, 31, 30, 31};
 
 // Returns number of years from (1, year).
-static constexpr int64_t getNumOfLeapYearsBefore(int64_t year) {
+static constexpr int64_t get_num_of_leap_years_before(int64_t year) {
   return (year / 4) - (year / 100) + (year / 400);
 }
 
 // Returns True if year is a leap year.
-static constexpr bool isLeapYear(const int64_t year) {
+static constexpr bool is_leap_year(const int64_t year) {
   return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
 }
 
 LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
   // Unlike most C Library functions, mktime doesn't just die on bad input.
   // TODO(rtenneti); Handle leap seconds.
-  int64_t tmYearFromBase = tm_out->tm_year + TimeConstants::TimeYearBase;
+  int64_t tm_year_from_base = tm_out->tm_year + TimeConstants::TIME_YEAR_BASE;
 
   // 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
   if (sizeof(time_t) == 4 &&
-      tmYearFromBase >= TimeConstants::EndOf32BitEpochYear) {
-    if (tmYearFromBase > TimeConstants::EndOf32BitEpochYear)
-      return time_utils::OutOfRange();
+      tm_year_from_base >= TimeConstants::END_OF32_BIT_EPOCH_YEAR) {
+    if (tm_year_from_base > TimeConstants::END_OF32_BIT_EPOCH_YEAR)
+      return time_utils::out_of_range();
     if (tm_out->tm_mon > 0)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
     if (tm_out->tm_mday > 19)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
     if (tm_out->tm_hour > 3)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
     if (tm_out->tm_min > 14)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
     if (tm_out->tm_sec > 7)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
   }
 
   // Years are ints.  A 32-bit year will fit into a 64-bit time_t.
   // A 64-bit year will not.
   static_assert(sizeof(int) == 4,
                 "ILP64 is unimplemented.  This implementation requires "
                 "32-bit integers.");
 
   // Calculate number of months and years from tm_mon.
   int64_t month = tm_out->tm_mon;
-  if (month < 0 || month >= TimeConstants::MonthsPerYear - 1) {
+  if (month < 0 || month >= TimeConstants::MONTHS_PER_YEAR - 1) {
     int64_t years = month / 12;
     month %= 12;
     if (month < 0) {
       years--;
       month += 12;
     }
-    tmYearFromBase += years;
+    tm_year_from_base += years;
   }
-  bool tmYearIsLeap = isLeapYear(tmYearFromBase);
+  bool tm_year_is_leap = is_leap_year(tm_year_from_base);
 
   // Calculate total number of days based on the month and the day (tm_mday).
-  int64_t totalDays = tm_out->tm_mday - 1;
+  int64_t total_days = tm_out->tm_mday - 1;
   for (int64_t i = 0; i < month; ++i)
-    totalDays += NonLeapYearDaysInMonth[i];
+    total_days += NON_LEAP_YEAR_DAYS_IN_MONTH[i];
   // Add one day if it is a leap year and the month is after February.
-  if (tmYearIsLeap && month > 1)
-    totalDays++;
+  if (tm_year_is_leap && month > 1)
+    total_days++;
 
   // Calculate total numbers of days based on the year.
-  totalDays += (tmYearFromBase - TimeConstants::EpochYear) *
-               TimeConstants::DaysPerNonLeapYear;
-  if (tmYearFromBase >= TimeConstants::EpochYear) {
-    totalDays += getNumOfLeapYearsBefore(tmYearFromBase - 1) -
-                 getNumOfLeapYearsBefore(TimeConstants::EpochYear);
-  } else if (tmYearFromBase >= 1) {
-    totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
-                 getNumOfLeapYearsBefore(tmYearFromBase - 1);
+  total_days += (tm_year_from_base - TimeConstants::EPOCH_YEAR) *
+                TimeConstants::DAYS_PER_NON_LEAP_YEAR;
+  if (tm_year_from_base >= TimeConstants::EPOCH_YEAR) {
+    total_days += get_num_of_leap_years_before(tm_year_from_base - 1) -
+                  get_num_of_leap_years_before(TimeConstants::EPOCH_YEAR);
+  } else if (tm_year_from_base >= 1) {
+    total_days -= get_num_of_leap_years_before(TimeConstants::EPOCH_YEAR) -
+                  get_num_of_leap_years_before(tm_year_from_base - 1);
   } else {
     // Calculate number of leap years until 0th year.
-    totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
-                 getNumOfLeapYearsBefore(0);
-    if (tmYearFromBase <= 0) {
-      totalDays -= 1; // Subtract 1 for 0th year.
+    total_days -= get_num_of_leap_years_before(TimeConstants::EPOCH_YEAR) -
+                  get_num_of_leap_years_before(0);
+    if (tm_year_from_base <= 0) {
+      total_days -= 1; // Subtract 1 for 0th year.
       // Calculate number of leap years until -1 year
-      if (tmYearFromBase < 0) {
-        totalDays -= getNumOfLeapYearsBefore(-tmYearFromBase) -
-                     getNumOfLeapYearsBefore(1);
+      if (tm_year_from_base < 0) {
+        total_days -= get_num_of_leap_years_before(-tm_year_from_base) -
+                      get_num_of_leap_years_before(1);
       }
     }
   }
 
   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
   int64_t seconds = tm_out->tm_sec +
-                    tm_out->tm_min * TimeConstants::SecondsPerMin +
-                    tm_out->tm_hour * TimeConstants::SecondsPerHour +
-                    totalDays * TimeConstants::SecondsPerDay;
+                    tm_out->tm_min * TimeConstants::SECONDS_PER_MIN +
+                    tm_out->tm_hour * TimeConstants::SECONDS_PER_HOUR +
+                    total_days * TimeConstants::SECONDS_PER_DAY;
 
   // Update the tm structure's year, month, day, etc. from seconds.
-  if (time_utils::UpdateFromSeconds(seconds, tm_out) < 0)
-    return time_utils::OutOfRange();
+  if (time_utils::update_from_seconds(seconds, tm_out) < 0)
+    return time_utils::out_of_range();
 
   return static_cast<time_t>(seconds);
 }
 
 } // namespace __llvm_libc

libc/src/time/time_utils.h

 #include "src/time/mktime.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace time_utils {
 
 struct TimeConstants {
-  static constexpr int SecondsPerMin = 60;
-  static constexpr int SecondsPerHour = 3600;
-  static constexpr int SecondsPerDay = 86400;
-  static constexpr int DaysPerWeek = 7;
-  static constexpr int MonthsPerYear = 12;
-  static constexpr int DaysPerNonLeapYear = 365;
-  static constexpr int DaysPerLeapYear = 366;
-  static constexpr int TimeYearBase = 1900;
-  static constexpr int EpochYear = 1970;
-  static constexpr int EpochWeekDay = 4;
-  static constexpr int NumberOfSecondsInLeapYear =
-      (DaysPerNonLeapYear + 1) * SecondsPerDay;
+  static constexpr int SECONDS_PER_MIN = 60;
+  static constexpr int SECONDS_PER_HOUR = 3600;
+  static constexpr int SECONDS_PER_DAY = 86400;
+  static constexpr int DAYS_PER_WEEK = 7;
+  static constexpr int MONTHS_PER_YEAR = 12;
+  static constexpr int DAYS_PER_NON_LEAP_YEAR = 365;
+  static constexpr int DAYS_PER_LEAP_YEAR = 366;
+  static constexpr int TIME_YEAR_BASE = 1900;
+  static constexpr int EPOCH_YEAR = 1970;
+  static constexpr int EPOCH_WEEK_DAY = 4;
+  static constexpr int NUMBER_OF_SECONDS_IN_LEAP_YEAR =
+      (DAYS_PER_NON_LEAP_YEAR + 1) * SECONDS_PER_DAY;
 
   // For asctime the behavior is undefined if struct tm's tm_wday or tm_mon are
   // not within the normal ranges as defined in <time.h>, or if struct tm's
   // tm_year exceeds {INT_MAX}-1990, or if the below asctime_internal algorithm
   // would attempt to generate more than 26 bytes of output (including the
   // terminating null).
-  static constexpr int AsctimeBufferSize = 256;
-  static constexpr int AsctimeMaxBytes = 26;
+  static constexpr int ASCTIME_BUFFER_SIZE = 256;
+  static constexpr int ASCTIME_MAX_BYTES = 26;
 
   /* 2000-03-01 (mod 400 year, immediately after feb29 */
-  static constexpr int64_t SecondsUntil2000MarchFirst =
-      (946684800LL + SecondsPerDay * (31 + 29));
-  static constexpr int WeekDayOf2000MarchFirst = 3;
-
-  static constexpr int DaysPer400Years =
-      (DaysPerNonLeapYear * 400 + (400 / 4) - 3);
-  static constexpr int DaysPer100Years =
-      (DaysPerNonLeapYear * 100 + (100 / 4) - 1);
-  static constexpr int DaysPer4Years = (DaysPerNonLeapYear * 4 + 1);
+  static constexpr int64_t SECONDS_UNTIL2000_MARCH_FIRST =
+      (946684800LL + SECONDS_PER_DAY * (31 + 29));
+  static constexpr int WEEK_DAY_OF2000_MARCH_FIRST = 3;
+
+  static constexpr int DAYS_PER400_YEARS =
+      (DAYS_PER_NON_LEAP_YEAR * 400 + (400 / 4) - 3);
+  static constexpr int DAYS_PER100_YEARS =
+      (DAYS_PER_NON_LEAP_YEAR * 100 + (100 / 4) - 1);
+  static constexpr int DAYS_PER4_YEARS = (DAYS_PER_NON_LEAP_YEAR * 4 + 1);
 
   // The latest time that can be represented in this form is 03:14:07 UTC on
   // Tuesday, 19 January 2038 (corresponding to 2,147,483,647 seconds since the
   // start of the epoch). This means that systems using a 32-bit time_t type are
   // susceptible to the Year 2038 problem.
-  static constexpr int EndOf32BitEpochYear = 2038;
+  static constexpr int END_OF32_BIT_EPOCH_YEAR = 2038;
 
-  static constexpr time_t OutOfRangeReturnValue = -1;
+  static constexpr time_t OUT_OF_RANGE_RETURN_VALUE = -1;
 };
 
 // Update the "tm" structure's year, month, etc. members from seconds.
 // "total_seconds" is the number of seconds since January 1st, 1970.
-extern int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm);
+extern int64_t update_from_seconds(int64_t total_seconds, struct tm *tm);
 
 // POSIX.1-2017 requires this.
-static inline time_t OutOfRange() {
+static inline time_t out_of_range() {
   llvmlibc_errno = EOVERFLOW;
   return static_cast<time_t>(-1);
 }
 
-static inline void InvalidValue() { llvmlibc_errno = EINVAL; }
+static inline void invalid_value() { llvmlibc_errno = EINVAL; }
 
 static inline char *asctime(const struct tm *timeptr, char *buffer,
                             size_t bufferLength) {
   if (timeptr == nullptr || buffer == nullptr) {
-    InvalidValue();
+    invalid_value();
     return nullptr;
   }
   if (timeptr->tm_wday < 0 ||
-      timeptr->tm_wday > (TimeConstants::DaysPerWeek - 1)) {
-    InvalidValue();
+      timeptr->tm_wday > (TimeConstants::DAYS_PER_WEEK - 1)) {
+    invalid_value();
     return nullptr;
   }
   if (timeptr->tm_mon < 0 ||
-      timeptr->tm_mon > (TimeConstants::MonthsPerYear - 1)) {
-    InvalidValue();
+      timeptr->tm_mon > (TimeConstants::MONTHS_PER_YEAR - 1)) {
+    invalid_value();
     return nullptr;
   }
 
   // TODO(rtenneti): i18n the following strings.
-  static const char *WeekDaysName[TimeConstants::DaysPerWeek] = {
+  static const char *week_days_name[TimeConstants::DAYS_PER_WEEK] = {
       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 
-  static const char *MonthsName[TimeConstants::MonthsPerYear] = {
+  static const char *months_name[TimeConstants::MONTHS_PER_YEAR] = {
       "Jan", "Feb", "Mar", "Apr", "May", "Jun",
       "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
   int written_size = __builtin_snprintf(
       buffer, bufferLength, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
-      WeekDaysName[timeptr->tm_wday], MonthsName[timeptr->tm_mon],
+      week_days_name[timeptr->tm_wday], months_name[timeptr->tm_mon],
       timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec,
-      TimeConstants::TimeYearBase + timeptr->tm_year);
+      TimeConstants::TIME_YEAR_BASE + timeptr->tm_year);
   if (written_size < 0)
     return nullptr;
   if (static_cast<size_t>(written_size) >= bufferLength) {
-    OutOfRange();
+    out_of_range();
     return nullptr;
   }
   return buffer;
 }
 
 static inline struct tm *gmtime_internal(const time_t *timer,
                                          struct tm *result) {
   int64_t seconds = *timer;
   // Update the tm structure's year, month, day, etc. from seconds.
-  if (UpdateFromSeconds(seconds, result) < 0) {
-    OutOfRange();
+  if (update_from_seconds(seconds, result) < 0) {
+    out_of_range();
     return nullptr;
   }
 
   return result;
 }
 
 } // namespace time_utils
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_TIME_TIME_UTILS_H

libc/src/time/time_utils.cpp

 // subdivides the days into the number of 400 years, the number of 100 years and
 // the number of 4 years. These numbers of cycle years are used in calculating
 // leap day. This is similar to the algorithm used in  getNumOfLeapYearsBefore()
 // and isLeapYear(). Then compute the total number of years in days from these
 // subdivided units.
 //
 // Compute the number of months from the remaining days. Finally, adjust years
 // to be 1900 and months to be from January.
-int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm) {
+int64_t update_from_seconds(int64_t total_seconds, struct tm *tm) {
   // Days in month starting from March in the year 2000.
   static const char daysInMonth[] = {31 /* Mar */, 30, 31, 30, 31, 31,
                                      30,           31, 30, 31, 31, 29};
 
   if (sizeof(time_t) == 4) {
     if (total_seconds < 0x80000000)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
     if (total_seconds > 0x7FFFFFFF)
-      return time_utils::OutOfRange();
+      return time_utils::out_of_range();
   } else {
     if (total_seconds <
             INT_MIN * static_cast<int64_t>(
-                          TimeConstants::NumberOfSecondsInLeapYear) ||
-        total_seconds > INT_MAX * static_cast<int64_t>(
-                                      TimeConstants::NumberOfSecondsInLeapYear))
-      return time_utils::OutOfRange();
+                          TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR) ||
+        total_seconds >
+            INT_MAX * static_cast<int64_t>(
+                          TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR))
+      return time_utils::out_of_range();
   }
 
-  int64_t seconds = total_seconds - TimeConstants::SecondsUntil2000MarchFirst;
-  int64_t days = seconds / TimeConstants::SecondsPerDay;
-  int64_t remainingSeconds = seconds % TimeConstants::SecondsPerDay;
+  int64_t seconds =
+      total_seconds - TimeConstants::SECONDS_UNTIL2000_MARCH_FIRST;
+  int64_t days = seconds / TimeConstants::SECONDS_PER_DAY;
+  int64_t remainingSeconds = seconds % TimeConstants::SECONDS_PER_DAY;
   if (remainingSeconds < 0) {
-    remainingSeconds += TimeConstants::SecondsPerDay;
+    remainingSeconds += TimeConstants::SECONDS_PER_DAY;
     days--;
   }
 
-  int64_t wday = (TimeConstants::WeekDayOf2000MarchFirst + days) %
-                 TimeConstants::DaysPerWeek;
+  int64_t wday = (TimeConstants::WEEK_DAY_OF2000_MARCH_FIRST + days) %
+                 TimeConstants::DAYS_PER_WEEK;
   if (wday < 0)
-    wday += TimeConstants::DaysPerWeek;
+    wday += TimeConstants::DAYS_PER_WEEK;
 
   // Compute the number of 400 year cycles.
-  int64_t numOfFourHundredYearCycles = days / TimeConstants::DaysPer400Years;
-  int64_t remainingDays = days % TimeConstants::DaysPer400Years;
+  int64_t numOfFourHundredYearCycles = days / TimeConstants::DAYS_PER400_YEARS;
+  int64_t remainingDays = days % TimeConstants::DAYS_PER400_YEARS;
   if (remainingDays < 0) {
-    remainingDays += TimeConstants::DaysPer400Years;
+    remainingDays += TimeConstants::DAYS_PER400_YEARS;
     numOfFourHundredYearCycles--;
   }
 
   // The reminder number of years after computing number of
   // "four hundred year cycles" will be 4 hundred year cycles or less in 400
   // years.
-  int64_t numOfHundredYearCycles =
-      computeRemainingYears(TimeConstants::DaysPer100Years, 4, &remainingDays);
+  int64_t numOfHundredYearCycles = computeRemainingYears(
+      TimeConstants::DAYS_PER100_YEARS, 4, &remainingDays);
 
   // The reminder number of years after computing number of
   // "hundred year cycles" will be 25 four year cycles or less in 100 years.
   int64_t numOfFourYearCycles =
-      computeRemainingYears(TimeConstants::DaysPer4Years, 25, &remainingDays);
+      computeRemainingYears(TimeConstants::DAYS_PER4_YEARS, 25, &remainingDays);
 
   // The reminder number of years after computing number of "four year cycles"
   // will be 4 one year cycles or less in 4 years.
   int64_t remainingYears = computeRemainingYears(
-      TimeConstants::DaysPerNonLeapYear, 4, &remainingDays);
+      TimeConstants::DAYS_PER_NON_LEAP_YEAR, 4, &remainingDays);
 
   // Calculate number of years from year 2000.
   int64_t years = remainingYears + 4 * numOfFourYearCycles +
                   100 * numOfHundredYearCycles +
                   400LL * numOfFourHundredYearCycles;
 
   int leapDay =
       !remainingYears && (numOfFourYearCycles || !numOfHundredYearCycles);
 
   int64_t yday = remainingDays + 31 + 28 + leapDay;
-  if (yday >= TimeConstants::DaysPerNonLeapYear + leapDay)
-    yday -= TimeConstants::DaysPerNonLeapYear + leapDay;
+  if (yday >= TimeConstants::DAYS_PER_NON_LEAP_YEAR + leapDay)
+    yday -= TimeConstants::DAYS_PER_NON_LEAP_YEAR + leapDay;
 
   int64_t months = 0;
   while (daysInMonth[months] <= remainingDays) {
     remainingDays -= daysInMonth[months];
     months++;
   }
 
-  if (months >= TimeConstants::MonthsPerYear - 2) {
-    months -= TimeConstants::MonthsPerYear;
+  if (months >= TimeConstants::MONTHS_PER_YEAR - 2) {
+    months -= TimeConstants::MONTHS_PER_YEAR;
     years++;
   }
 
   if (years > INT_MAX || years < INT_MIN)
-    return time_utils::OutOfRange();
+    return time_utils::out_of_range();
 
   // All the data (years, month and remaining days) was calculated from
   // March, 2000. Thus adjust the data to be from January, 1900.
-  tm->tm_year = years + 2000 - TimeConstants::TimeYearBase;
+  tm->tm_year = years + 2000 - TimeConstants::TIME_YEAR_BASE;
   tm->tm_mon = months + 2;
   tm->tm_mday = remainingDays + 1;
   tm->tm_wday = wday;
   tm->tm_yday = yday;
 
-  tm->tm_hour = remainingSeconds / TimeConstants::SecondsPerHour;
-  tm->tm_min = remainingSeconds / TimeConstants::SecondsPerMin %
-               TimeConstants::SecondsPerMin;
-  tm->tm_sec = remainingSeconds % TimeConstants::SecondsPerMin;
+  tm->tm_hour = remainingSeconds / TimeConstants::SECONDS_PER_HOUR;
+  tm->tm_min = remainingSeconds / TimeConstants::SECONDS_PER_MIN %
+               TimeConstants::SECONDS_PER_MIN;
+  tm->tm_sec = remainingSeconds % TimeConstants::SECONDS_PER_MIN;
   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
   tm->tm_isdst = 0;
 
   return 0;
 }
 
 } // namespace time_utils
 } // namespace __llvm_libc

libc/test/src/__support/endian_test.cpp

 //===-- Unittests for endian ----------------------------------------------===//
 //
 // 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 "src/__support/endian.h"
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 
 struct LlvmLibcEndian : testing::Test {
   template <typename T> void check(const T original, const T swapped) {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    EXPECT_EQ(Endian::ToLittleEndian(original), original);
-    EXPECT_EQ(Endian::ToBigEndian(original), swapped);
+    EXPECT_EQ(Endian::to_little_endian(original), original);
+    EXPECT_EQ(Endian::to_big_endian(original), swapped);
 #endif
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    EXPECT_EQ(Endian::ToBigEndian(original), original);
-    EXPECT_EQ(Endian::ToLittleEndian(original), swapped);
+    EXPECT_EQ(Endian::to_big_endian(original), original);
+    EXPECT_EQ(Endian::to_little_endian(original), swapped);
 #endif
   }
 };
 
 TEST_F(LlvmLibcEndian, Field) {
-  EXPECT_EQ(Endian::isLittle, __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__);
-  EXPECT_EQ(Endian::isBig, __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__);
+  EXPECT_EQ(Endian::IS_LITTLE, __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__);
+  EXPECT_EQ(Endian::IS_BIG, __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__);
 }
 
 TEST_F(LlvmLibcEndian, uint8_t) {
   const uint8_t original = uint8_t(0x12);
   check(original, original);
 }
 
 TEST_F(LlvmLibcEndian, uint16_t) {

libc/test/src/__support/high_precision_decimal_test.cpp

 //===-- Unittests for high_precision_decimal ------------------------------===//
 //
 // 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 "src/__support/high_precision_decimal.h"
 
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BasicInit) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(3));
   EXPECT_EQ(digits[3], uint8_t(4));
   EXPECT_EQ(digits[4], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 5u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 5u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BasicShift) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(1); // shift left 1, equal to multiplying by 2.
 
   EXPECT_EQ(digits[0], uint8_t(2));
-  EXPECT_EQ(hpd.getNumDigits(), 1u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 1u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(-1); // shift right one, equal to dividing by 2
   // result should be 0.61725
 
   EXPECT_EQ(digits[0], uint8_t(6));
   EXPECT_EQ(digits[1], uint8_t(1));
   EXPECT_EQ(digits[2], uint8_t(7));
   EXPECT_EQ(digits[3], uint8_t(2));
   EXPECT_EQ(digits[4], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 5u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 0);
+  EXPECT_EQ(hpd.get_num_digits(), 5u);
+  EXPECT_EQ(hpd.get_decimal_point(), 0);
 
   hpd.shift(1); // shift left one, equal to multiplying by 2
   // result should be 1.2345 again
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(3));
   EXPECT_EQ(digits[3], uint8_t(4));
   EXPECT_EQ(digits[4], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 5u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 5u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 
   hpd.shift(1); // shift left one again
   // result should be 2.469
 
   EXPECT_EQ(digits[0], uint8_t(2));
   EXPECT_EQ(digits[1], uint8_t(4));
   EXPECT_EQ(digits[2], uint8_t(6));
   EXPECT_EQ(digits[3], uint8_t(9));
-  EXPECT_EQ(hpd.getNumDigits(), 4u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 4u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 
   hpd.shift(-1); // shift right one again
   // result should be 1.2345 again
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(3));
   EXPECT_EQ(digits[3], uint8_t(4));
   EXPECT_EQ(digits[4], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 5u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 5u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, MediumShift) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal(".299792458");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(-3); // shift right three, equal to dividing by 8
   // result should be 0.03747405725
 
   EXPECT_EQ(digits[0], uint8_t(3));
   EXPECT_EQ(digits[1], uint8_t(7));
   EXPECT_EQ(digits[2], uint8_t(4));
   EXPECT_EQ(digits[3], uint8_t(7));
   EXPECT_EQ(digits[4], uint8_t(4));
   EXPECT_EQ(digits[5], uint8_t(0));
   EXPECT_EQ(digits[6], uint8_t(5));
   EXPECT_EQ(digits[7], uint8_t(7));
   EXPECT_EQ(digits[8], uint8_t(2));
   EXPECT_EQ(digits[9], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 10u);
-  EXPECT_EQ(hpd.getDecimalPoint(), -1);
+  EXPECT_EQ(hpd.get_num_digits(), 10u);
+  EXPECT_EQ(hpd.get_decimal_point(), -1);
 
   hpd.shift(3); // shift left three, equal to multiplying by 8
   // result should be 0.299792458 again
 
   EXPECT_EQ(digits[0], uint8_t(2));
   EXPECT_EQ(digits[1], uint8_t(9));
   EXPECT_EQ(digits[2], uint8_t(9));
   EXPECT_EQ(digits[3], uint8_t(7));
   EXPECT_EQ(digits[4], uint8_t(9));
   EXPECT_EQ(digits[5], uint8_t(2));
   EXPECT_EQ(digits[6], uint8_t(4));
   EXPECT_EQ(digits[7], uint8_t(5));
   EXPECT_EQ(digits[8], uint8_t(8));
-  EXPECT_EQ(hpd.getNumDigits(), 9u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 0);
+  EXPECT_EQ(hpd.get_num_digits(), 9u);
+  EXPECT_EQ(hpd.get_decimal_point(), 0);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal(".299792458");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(-29); // shift right 29, equal to dividing by 536,870,912
   // result should be 0.0000000005584069676697254180908203125
 
   EXPECT_EQ(digits[0], uint8_t(5));
   EXPECT_EQ(digits[1], uint8_t(5));
   EXPECT_EQ(digits[2], uint8_t(8));
   EXPECT_EQ(digits[3], uint8_t(4));
TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
   EXPECT_EQ(digits[20], uint8_t(0));
   EXPECT_EQ(digits[21], uint8_t(8));
   EXPECT_EQ(digits[22], uint8_t(2));
   EXPECT_EQ(digits[23], uint8_t(0));
   EXPECT_EQ(digits[24], uint8_t(3));
   EXPECT_EQ(digits[25], uint8_t(1));
   EXPECT_EQ(digits[26], uint8_t(2));
   EXPECT_EQ(digits[27], uint8_t(5));
-  EXPECT_EQ(hpd.getNumDigits(), 28u);
-  EXPECT_EQ(hpd.getDecimalPoint(), -9);
+  EXPECT_EQ(hpd.get_num_digits(), 28u);
+  EXPECT_EQ(hpd.get_decimal_point(), -9);
 
   hpd.shift(29); // shift left 29, equal to multiplying by 536,870,912
   // result should be 0.299792458 again
 
   EXPECT_EQ(digits[0], uint8_t(2));
   EXPECT_EQ(digits[1], uint8_t(9));
   EXPECT_EQ(digits[2], uint8_t(9));
   EXPECT_EQ(digits[3], uint8_t(7));
   EXPECT_EQ(digits[4], uint8_t(9));
   EXPECT_EQ(digits[5], uint8_t(2));
   EXPECT_EQ(digits[6], uint8_t(4));
   EXPECT_EQ(digits[7], uint8_t(5));
   EXPECT_EQ(digits[8], uint8_t(8));
-  EXPECT_EQ(hpd.getNumDigits(), 9u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 0);
+  EXPECT_EQ(hpd.get_num_digits(), 9u);
+  EXPECT_EQ(hpd.get_decimal_point(), 0);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(60); // shift left 60, equal to multiplying by
                  // 1152921504606846976.
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(1));
   EXPECT_EQ(digits[2], uint8_t(5));
   EXPECT_EQ(digits[3], uint8_t(2));
   EXPECT_EQ(digits[4], uint8_t(9));
   EXPECT_EQ(digits[5], uint8_t(2));
   EXPECT_EQ(digits[6], uint8_t(1));
   EXPECT_EQ(digits[7], uint8_t(5));
   EXPECT_EQ(digits[8], uint8_t(0));
   EXPECT_EQ(digits[9], uint8_t(4));
   EXPECT_EQ(digits[10], uint8_t(6));
   EXPECT_EQ(digits[11], uint8_t(0));
   EXPECT_EQ(digits[12], uint8_t(6));
   EXPECT_EQ(digits[13], uint8_t(8));
   EXPECT_EQ(digits[14], uint8_t(4));
   EXPECT_EQ(digits[15], uint8_t(6));
   EXPECT_EQ(digits[16], uint8_t(9));
   EXPECT_EQ(digits[17], uint8_t(7));
   EXPECT_EQ(digits[18], uint8_t(6));
-  EXPECT_EQ(hpd.getNumDigits(), 19u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 19);
+  EXPECT_EQ(hpd.get_num_digits(), 19u);
+  EXPECT_EQ(hpd.get_decimal_point(), 19);
 
   hpd.shift(40); // shift left 40, equal to multiplying by
                  // 1099511627776. Result should be 2^100
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(6));
   EXPECT_EQ(digits[3], uint8_t(7));
TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
   EXPECT_EQ(digits[24], uint8_t(3));
   EXPECT_EQ(digits[25], uint8_t(2));
   EXPECT_EQ(digits[26], uint8_t(0));
   EXPECT_EQ(digits[27], uint8_t(5));
   EXPECT_EQ(digits[28], uint8_t(3));
   EXPECT_EQ(digits[29], uint8_t(7));
   EXPECT_EQ(digits[30], uint8_t(6));
 
-  EXPECT_EQ(hpd.getNumDigits(), 31u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 31);
+  EXPECT_EQ(hpd.get_num_digits(), 31u);
+  EXPECT_EQ(hpd.get_decimal_point(), 31);
 
   hpd.shift(-60); // shift right 60, equal to dividing by
                   // 1152921504606846976. Result should be 2^40
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(0));
   EXPECT_EQ(digits[2], uint8_t(9));
   EXPECT_EQ(digits[3], uint8_t(9));
   EXPECT_EQ(digits[4], uint8_t(5));
   EXPECT_EQ(digits[5], uint8_t(1));
   EXPECT_EQ(digits[6], uint8_t(1));
   EXPECT_EQ(digits[7], uint8_t(6));
   EXPECT_EQ(digits[8], uint8_t(2));
   EXPECT_EQ(digits[9], uint8_t(7));
   EXPECT_EQ(digits[10], uint8_t(7));
   EXPECT_EQ(digits[11], uint8_t(7));
   EXPECT_EQ(digits[12], uint8_t(6));
 
-  EXPECT_EQ(hpd.getNumDigits(), 13u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 13);
+  EXPECT_EQ(hpd.get_num_digits(), 13u);
+  EXPECT_EQ(hpd.get_decimal_point(), 13);
 
   hpd.shift(-40); // shift right 40, equal to dividing by
                   // 1099511627776. Result should be 1
 
   EXPECT_EQ(digits[0], uint8_t(1));
 
-  EXPECT_EQ(hpd.getNumDigits(), 1u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 1u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, VeryBigShift) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1");
-  uint8_t *digits = hpd.getDigits();
+  uint8_t *digits = hpd.get_digits();
 
   hpd.shift(100); // shift left 100, equal to multiplying by
                   // 1267650600228229401496703205376.
   // result should be 2^100
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(6));
TEST(LlvmLibcHighPrecisionDecimalTest, VeryBigShift) {
   EXPECT_EQ(digits[24], uint8_t(3));
   EXPECT_EQ(digits[25], uint8_t(2));
   EXPECT_EQ(digits[26], uint8_t(0));
   EXPECT_EQ(digits[27], uint8_t(5));
   EXPECT_EQ(digits[28], uint8_t(3));
   EXPECT_EQ(digits[29], uint8_t(7));
   EXPECT_EQ(digits[30], uint8_t(6));
 
-  EXPECT_EQ(hpd.getNumDigits(), 31u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 31);
+  EXPECT_EQ(hpd.get_num_digits(), 31u);
+  EXPECT_EQ(hpd.get_decimal_point(), 31);
 
   hpd.shift(-100); // shift right 100, equal to dividing by
                    // 1267650600228229401496703205376.
   // result should be 1
 
   EXPECT_EQ(digits[0], uint8_t(1));
-  EXPECT_EQ(hpd.getNumDigits(), 1u);
-  EXPECT_EQ(hpd.getDecimalPoint(), 1);
+  EXPECT_EQ(hpd.get_num_digits(), 1u);
+  EXPECT_EQ(hpd.get_decimal_point(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
   __llvm_libc::internal::HighPrecisionDecimal hpd =
       __llvm_libc::internal::HighPrecisionDecimal("1.2345");
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(1));
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(1));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(1));
+  EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(1));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(1));
 
   hpd.shift(1); // shift left 1 to get 2.469 (rounds to 2)
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(2));
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(2));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
 
   hpd.shift(1); // shift left 1 to get 4.938 (rounds to 5)
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(5));
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(5));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(5));
+  EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(5));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(5));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(5));
 
   // 2.5 is right between two integers, so we round to even (2)
   hpd = __llvm_libc::internal::HighPrecisionDecimal("2.5");
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(2));
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(2));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(2));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(2));
 
   // unless it's marked as having truncated, which means it's actually slightly
   // higher, forcing a round up (3)
-  hpd.setTruncated(true);
+  hpd.set_truncated(true);
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(3));
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(3));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(3));
+  EXPECT_EQ(hpd.round_to_integer_type<uint32_t>(), uint32_t(3));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(3));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), __uint128_t(3));
 
   // Check that the larger int types are being handled properly (overflow is not
   // handled, so int types that are too small are ignored for this test.)
 
   // 1099511627776 = 2^40
   hpd = __llvm_libc::internal::HighPrecisionDecimal("1099511627776");
 
-  EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(1099511627776));
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(1099511627776));
+  EXPECT_EQ(hpd.round_to_integer_type<uint64_t>(), uint64_t(1099511627776));
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(),
+            __uint128_t(1099511627776));
 
   // 1267650600228229401496703205376 = 2^100
   hpd = __llvm_libc::internal::HighPrecisionDecimal(
       "1267650600228229401496703205376");
 
   __uint128_t result = __uint128_t(1) << 100;
 
-  EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), result);
+  EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
 }

libc/test/src/__support/str_to_float_test.cpp

void ClingerFastPathTest(
       const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
       const int32_t inputExp10,
       const typename __llvm_libc::fputil::FPBits<T>::UIntType
           expectedOutputMantissa,
       const uint32_t expectedOutputExp2) {
     typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
     uint32_t actualOutputExp2 = 0;
 
-    ASSERT_TRUE(__llvm_libc::internal::clingerFastPath<T>(
+    ASSERT_TRUE(__llvm_libc::internal::clinger_fast_path<T>(
         inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
     EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
     EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
   }
 
   template <class T>
   void ClingerFastPathFailsTest(
       const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
       const int32_t inputExp10) {
     typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
     uint32_t actualOutputExp2 = 0;
 
-    ASSERT_FALSE(__llvm_libc::internal::clingerFastPath<T>(
+    ASSERT_FALSE(__llvm_libc::internal::clinger_fast_path<T>(
         inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
   }
 
   template <class T>
   void EiselLemireTest(
       const typename __llvm_libc::fputil::FPBits<T>::UIntType inputMantissa,
       const int32_t inputExp10,
       const typename __llvm_libc::fputil::FPBits<T>::UIntType
           expectedOutputMantissa,
       const uint32_t expectedOutputExp2) {
     typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
     uint32_t actualOutputExp2 = 0;
 
-    ASSERT_TRUE(__llvm_libc::internal::eiselLemire<T>(
+    ASSERT_TRUE(__llvm_libc::internal::eisel_lemire<T>(
         inputMantissa, inputExp10, &actualOutputMantissa, &actualOutputExp2));
     EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
     EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
   }
 
   template <class T>
   void SimpleDecimalConversionTest(
       const char *__restrict numStart,
       const typename __llvm_libc::fputil::FPBits<T>::UIntType
           expectedOutputMantissa,
       const uint32_t expectedOutputExp2, const int expectedErrno = 0) {
     typename __llvm_libc::fputil::FPBits<T>::UIntType actualOutputMantissa = 0;
     uint32_t actualOutputExp2 = 0;
     errno = 0;
 
-    __llvm_libc::internal::simpleDecimalConversion<T>(
+    __llvm_libc::internal::simple_decimal_conversion<T>(
         numStart, &actualOutputMantissa, &actualOutputExp2);
     EXPECT_EQ(actualOutputMantissa, expectedOutputMantissa);
     EXPECT_EQ(actualOutputExp2, expectedOutputExp2);
     EXPECT_EQ(errno, expectedErrno);
   }
 };
 
 TEST(LlvmLibcStrToFloatTest, LeadingZeroes) {
   uint64_t testNum64 = 1;
   uint32_t numOfZeroes = 63;
-  EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint64_t>(0), 64u);
+  EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0), 64u);
   for (; numOfZeroes < 64; testNum64 <<= 1, numOfZeroes--) {
-    EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint64_t>(testNum64),
+    EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
               numOfZeroes);
   }
 
   testNum64 = 3;
   numOfZeroes = 62;
   for (; numOfZeroes > 63; testNum64 <<= 1, numOfZeroes--) {
-    EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint64_t>(testNum64),
+    EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
               numOfZeroes);
   }
 
-  EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint64_t>(0xffffffffffffffff),
+  EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(0xffffffffffffffff),
             0u);
 
   testNum64 = 1;
   numOfZeroes = 63;
   for (; numOfZeroes > 63; testNum64 = (testNum64 << 1) + 1, numOfZeroes--) {
-    EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint64_t>(testNum64),
+    EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint64_t>(testNum64),
               numOfZeroes);
   }
 
   uint64_t testNum32 = 1;
   numOfZeroes = 31;
-  EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint32_t>(0), 32u);
+  EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0), 32u);
   for (; numOfZeroes < 32; testNum32 <<= 1, numOfZeroes--) {
-    EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint32_t>(testNum32),
+    EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(testNum32),
               numOfZeroes);
   }
 
-  EXPECT_EQ(__llvm_libc::internal::leadingZeroes<uint32_t>(0xffffffff), 0u);
+  EXPECT_EQ(__llvm_libc::internal::leading_zeroes<uint32_t>(0xffffffff), 0u);
 }
 
 TEST_F(LlvmLibcStrToFloatTest, ClingerFastPathFloat64Simple) {
   ClingerFastPathTest<double>(123, 0, 0xEC00000000000, 1029);
   ClingerFastPathTest<double>(1234567890123456, 1, 0x5ee2a2eb5a5c0, 1076);
   ClingerFastPathTest<double>(1234567890, -10, 0xf9add3739635f, 1019);
 }
 

 TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) {
   // Check the fallback states for the algorithm:
   uint32_t floatOutputMantissa = 0;
   uint64_t doubleOutputMantissa = 0;
   __uint128_t tooLongMantissa = 0;
   uint32_t outputExp2 = 0;
 
   // This Eisel-Lemire implementation doesn't support long doubles yet.
-  ASSERT_FALSE(__llvm_libc::internal::eiselLemire<long double>(
+  ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<long double>(
       tooLongMantissa, 0, &tooLongMantissa, &outputExp2));
 
   // This number can't be evaluated by Eisel-Lemire since it's exactly 1024 away
   // from both of its closest floating point approximations
   // (12345678901234548736 and 12345678901234550784)
-  ASSERT_FALSE(__llvm_libc::internal::eiselLemire<double>(
+  ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<double>(
       12345678901234549760u, 0, &doubleOutputMantissa, &outputExp2));
 
-  ASSERT_FALSE(__llvm_libc::internal::eiselLemire<float>(
+  ASSERT_FALSE(__llvm_libc::internal::eisel_lemire<float>(
       20040229, 0, &floatOutputMantissa, &outputExp2));
 }
 
 TEST_F(LlvmLibcStrToFloatTest, SimpleDecimalConversion64BasicWholeNumbers) {
   SimpleDecimalConversionTest<double>("123456789012345678900", 0x1AC53A7E04BCDA,
                                       1089);
   SimpleDecimalConversionTest<double>("123", 0x1EC00000000000, 1029);
   SimpleDecimalConversionTest<double>("12345678901234549760", 0x156A95319D63D8,
SimpleDecimalConversionTest<float>(
       ERANGE);
 }
 
 TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
   uint32_t floatOutputMantissa = 0;
   uint32_t outputExp2 = 0;
 
   errno = 0;
-  __llvm_libc::internal::simpleDecimalConversion<float>(
+  __llvm_libc::internal::simple_decimal_conversion<float>(
       "123456789012345678900", &floatOutputMantissa, &outputExp2);
   EXPECT_EQ(floatOutputMantissa, uint32_t(0xd629d4));
   EXPECT_EQ(outputExp2, uint32_t(193));
   EXPECT_EQ(errno, 0);
 
   uint64_t doubleOutputMantissa = 0;
   outputExp2 = 0;
 
   errno = 0;
-  __llvm_libc::internal::simpleDecimalConversion<double>(
+  __llvm_libc::internal::simple_decimal_conversion<double>(
       "123456789012345678900", &doubleOutputMantissa, &outputExp2);
   EXPECT_EQ(doubleOutputMantissa, uint64_t(0x1AC53A7E04BCDA));
   EXPECT_EQ(outputExp2, uint32_t(1089));
   EXPECT_EQ(errno, 0);
 
   // TODO(michaelrj): Get long double support working.
 
   // __uint128_t longDoubleOutputMantissa = 0;
   // outputExp2 = 0;
 
   // errno = 0;
-  // __llvm_libc::internal::simpleDecimalConversion<long double>(
+  // __llvm_libc::internal::simple_decimal_conversion<long double>(
   //     "123456789012345678900", &longDoubleOutputMantissa, &outputExp2);
   // EXPECT_EQ(longDoubleOutputMantissa, __uint128_t(0x1AC53A7E04BCDA));
   // EXPECT_EQ(outputExp2, uint32_t(1089));
   // EXPECT_EQ(errno, 0);
 }

libc/test/src/fenv/enabled_exceptions_test.cpp

 #if defined(LLVM_LIBC_ARCH_AARCH64)
   // Few aarch64 HW implementations do not trap exceptions. We skip this test
   // completely on such HW.
   //
   // Whether HW supports trapping exceptions or not is deduced by enabling an
   // exception and reading back to see if the exception got enabled. If the
   // exception did not get enabled, then it means that the HW does not support
   // trapping exceptions.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
-  if (__llvm_libc::fputil::getExcept() == 0)
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::enable_except(FE_DIVBYZERO);
+  if (__llvm_libc::fputil::get_except() == 0)
     return;
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
   // TODO: Install a floating point exception handler and verify that the
   // the expected exception was raised. One will have to longjmp back from
   // that exception handler, so such a testing can be done after we have
   // longjmp implemented.
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   // We '|' the individual exception flags instead of using FE_ALL_EXCEPT
   // as it can include non-standard extensions. Note that we should be able
   // to compile this file with headers from other libcs as well.
   constexpr int allExcepts =
       FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
 
   for (int e : excepts) {
-    __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-    __llvm_libc::fputil::enableExcept(e);
+    __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::enable_except(e);
     ASSERT_EQ(__llvm_libc::feclearexcept(FE_ALL_EXCEPT), 0);
     // Raising all exceptions except |e| should not call the
     // SIGFPE handler. They should set the exception flag though,
     // so we verify that. Since other exceptions like FE_DIVBYZERO
     // can raise FE_INEXACT as well, we don't verify the other
     // exception flags when FE_INEXACT is enabled.
     if (e != FE_INEXACT) {
       int others = allExcepts & ~e;
       ASSERT_EQ(__llvm_libc::feraiseexcept(others), 0);
       ASSERT_EQ(__llvm_libc::fetestexcept(others), others);
     }
 
     ASSERT_RAISES_FP_EXCEPT([=] {
       // In test frameworks like Fuchsia's zxtest, this translates to
       // a death test which runs this closure in a different thread. So,
       // we enable the exception again inside this closure so that the
       // exception gets enabled for the thread running this closure.
-      __llvm_libc::fputil::enableExcept(e);
+      __llvm_libc::fputil::enable_except(e);
       __llvm_libc::feraiseexcept(e);
     });
 
     // Cleanup.
-    __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
     ASSERT_EQ(__llvm_libc::feclearexcept(FE_ALL_EXCEPT), 0);
   }
 }

libc/test/src/fenv/exception_flags_test.cpp

 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFenvTest, GetExceptFlagAndSetExceptFlag) {
   // We will disable all exceptions to prevent invocation of the exception
   // handler.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
     // The overall idea is to raise an except and save the exception flags.
     // Next, clear the flags and then set the saved exception flags. This
     // should set the flag corresponding to the previously raised exception.
-    __llvm_libc::fputil::raiseExcept(e);
+    __llvm_libc::fputil::raise_except(e);
     // Make sure that the exception flag is set.
-    ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_NE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
 
     fexcept_t eflags;
     ASSERT_EQ(__llvm_libc::fegetexceptflag(&eflags, FE_ALL_EXCEPT), 0);
 
-    __llvm_libc::fputil::clearExcept(e);
-    ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    __llvm_libc::fputil::clear_except(e);
+    ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
 
     ASSERT_EQ(__llvm_libc::fesetexceptflag(&eflags, FE_ALL_EXCEPT), 0);
-    ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_NE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
 
     // Cleanup. We clear all excepts as raising excepts like FE_OVERFLOW
     // can also raise FE_INEXACT.
-    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
   }
 
   // Next, we will raise one exception and save the flags.
-  __llvm_libc::fputil::raiseExcept(FE_INVALID);
+  __llvm_libc::fputil::raise_except(FE_INVALID);
   fexcept_t eflags;
   __llvm_libc::fegetexceptflag(&eflags, FE_ALL_EXCEPT);
   // Clear all exceptions and raise two other exceptions.
-  __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::raiseExcept(FE_OVERFLOW | FE_INEXACT);
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::raise_except(FE_OVERFLOW | FE_INEXACT);
   // When we set the flags and test, we should only see FE_INVALID.
   __llvm_libc::fesetexceptflag(&eflags, FE_ALL_EXCEPT);
-  EXPECT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT), FE_INVALID);
+  EXPECT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), FE_INVALID);
 }

libc/test/src/fenv/exception_status_test.cpp

 
 #include <fenv.h>
 
 TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
   // This test raises a set of exceptions and checks that the exception
   // status flags are updated. The intention is really not to invoke the
   // exception handler. Hence, we will disable all exceptions at the
   // beginning.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   constexpr int allExcepts =
       FE_DIVBYZERO | FE_INVALID | FE_INEXACT | FE_OVERFLOW | FE_UNDERFLOW;
 
   for (int e : excepts) {

libc/test/src/fenv/feclearexcept_test.cpp

 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <stdint.h>
 
 TEST(LlvmLibcFEnvTest, ClearTest) {
   uint16_t excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                         FE_UNDERFLOW};
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
   for (uint16_t e : excepts)
-    ASSERT_EQ(__llvm_libc::fputil::testExcept(e), 0);
+    ASSERT_EQ(__llvm_libc::fputil::test_except(e), 0);
 
-  __llvm_libc::fputil::raiseExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::raise_except(FE_ALL_EXCEPT);
   for (uint16_t e : excepts) {
     // We clear one exception and test to verify that it was cleared.
     __llvm_libc::feclearexcept(e);
-    ASSERT_EQ(uint16_t(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT)),
+    ASSERT_EQ(uint16_t(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT)),
               uint16_t(FE_ALL_EXCEPT & ~e));
     // After clearing, we raise the exception again.
-    __llvm_libc::fputil::raiseExcept(e);
+    __llvm_libc::fputil::raise_except(e);
   }
 
   for (uint16_t e1 : excepts) {
     for (uint16_t e2 : excepts) {
       __llvm_libc::feclearexcept(e1 | e2);
-      ASSERT_EQ(uint16_t(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT)),
+      ASSERT_EQ(uint16_t(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT)),
                 uint16_t(FE_ALL_EXCEPT & ~(e1 | e2)));
-      __llvm_libc::fputil::raiseExcept(e1 | e2);
+      __llvm_libc::fputil::raise_except(e1 | e2);
     }
   }
 
   for (uint16_t e1 : excepts) {
     for (uint16_t e2 : excepts) {
       for (uint16_t e3 : excepts) {
         __llvm_libc::feclearexcept(e1 | e2 | e3);
-        ASSERT_EQ(uint16_t(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT)),
+        ASSERT_EQ(uint16_t(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT)),
                   uint16_t(FE_ALL_EXCEPT & ~(e1 | e2 | e3)));
-        __llvm_libc::fputil::raiseExcept(e1 | e2 | e3);
+        __llvm_libc::fputil::raise_except(e1 | e2 | e3);
       }
     }
   }
 
   for (uint16_t e1 : excepts) {
     for (uint16_t e2 : excepts) {
       for (uint16_t e3 : excepts) {
         for (uint16_t e4 : excepts) {
           __llvm_libc::feclearexcept(e1 | e2 | e3 | e4);
-          ASSERT_EQ(uint16_t(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT)),
+          ASSERT_EQ(uint16_t(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT)),
                     uint16_t(FE_ALL_EXCEPT & ~(e1 | e2 | e3 | e4)));
-          __llvm_libc::fputil::raiseExcept(e1 | e2 | e3 | e4);
+          __llvm_libc::fputil::raise_except(e1 | e2 | e3 | e4);
         }
       }
     }
   }
 
   for (uint16_t e1 : excepts) {
     for (uint16_t e2 : excepts) {
       for (uint16_t e3 : excepts) {
         for (uint16_t e4 : excepts) {
           for (uint16_t e5 : excepts) {
             __llvm_libc::feclearexcept(e1 | e2 | e3 | e4 | e5);
-            ASSERT_EQ(uint16_t(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT)),
+            ASSERT_EQ(uint16_t(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT)),
                       uint16_t(FE_ALL_EXCEPT & ~(e1 | e2 | e3 | e4 | e5)));
-            __llvm_libc::fputil::raiseExcept(e1 | e2 | e3 | e4 | e5);
+            __llvm_libc::fputil::raise_except(e1 | e2 | e3 | e4 | e5);
           }
         }
       }
     }
   }
 }

libc/test/src/fenv/feholdexcept_test.cpp

 #if defined(LLVM_LIBC_ARCH_AARCH64)
   // Few aarch64 HW implementations do not trap exceptions. We skip this test
   // completely on such HW.
   //
   // Whether HW supports trapping exceptions or not is deduced by enabling an
   // exception and reading back to see if the exception got enabled. If the
   // exception did not get enabled, then it means that the HW does not support
   // trapping exceptions.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
-  if (__llvm_libc::fputil::getExcept() == 0)
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::enable_except(FE_DIVBYZERO);
+  if (__llvm_libc::fputil::get_except() == 0)
     return;
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
     fenv_t env;
-    __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-    __llvm_libc::fputil::enableExcept(e);
-    ASSERT_EQ(__llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT), 0);
+    __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::enable_except(e);
+    ASSERT_EQ(__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT), 0);
     ASSERT_EQ(__llvm_libc::feholdexcept(&env), 0);
     // feholdexcept should disable all excepts so raising an exception
     // should not crash/invoke the exception handler.
-    ASSERT_EQ(__llvm_libc::fputil::raiseExcept(e), 0);
+    ASSERT_EQ(__llvm_libc::fputil::raise_except(e), 0);
 
     ASSERT_RAISES_FP_EXCEPT([=] {
       // When we put back the saved env, which has the exception enabled, it
       // should crash with SIGFPE. Note that we set the old environment
       // back inside this closure because in some test frameworks like Fuchsia's
       // zxtest, this test translates to a death test in which this closure is
       // run in a different thread. So, we set the old environment inside
       // this closure so that the exception gets enabled for the thread running
       // this closure.
-      __llvm_libc::fputil::setEnv(&env);
-      __llvm_libc::fputil::raiseExcept(e);
+      __llvm_libc::fputil::set_env(&env);
+      __llvm_libc::fputil::raise_except(e);
     });
 
     // Cleanup
-    __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-    ASSERT_EQ(__llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT), 0);
+    __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+    ASSERT_EQ(__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT), 0);
   }
 }

libc/test/src/fenv/feupdateenv_test.cpp

 
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 TEST(LlvmLibcFEnvTest, UpdateEnvTest) {
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
-  __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
   fenv_t env;
-  ASSERT_EQ(__llvm_libc::fputil::getEnv(&env), 0);
-  __llvm_libc::fputil::setExcept(FE_INVALID | FE_INEXACT);
+  ASSERT_EQ(__llvm_libc::fputil::get_env(&env), 0);
+  __llvm_libc::fputil::set_except(FE_INVALID | FE_INEXACT);
   ASSERT_EQ(__llvm_libc::feupdateenv(&env), 0);
-  ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_INVALID | FE_INEXACT),
+  ASSERT_EQ(__llvm_libc::fputil::test_except(FE_INVALID | FE_INEXACT),
             FE_INVALID | FE_INEXACT);
 }

libc/test/src/fenv/getenv_and_setenv_test.cpp

 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFenvTest, GetEnvAndSetEnv) {
   // We will disable all exceptions to prevent invocation of the exception
   // handler.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
-    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
     // Save the cleared environment.
     fenv_t env;
     ASSERT_EQ(__llvm_libc::fegetenv(&env), 0);
 
-    __llvm_libc::fputil::raiseExcept(e);
+    __llvm_libc::fputil::raise_except(e);
     // Make sure that the exception is raised.
-    ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_NE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
 
     ASSERT_EQ(__llvm_libc::fesetenv(&env), 0);
-    ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
   }
 }
 
 TEST(LlvmLibcFenvTest, Set_FE_DFL_ENV) {
   // We will disable all exceptions to prevent invocation of the exception
   // handler.
-  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
-    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 
     // Save the cleared environment.
     fenv_t env;
     ASSERT_EQ(__llvm_libc::fegetenv(&env), 0);
 
-    __llvm_libc::fputil::raiseExcept(e);
+    __llvm_libc::fputil::raise_except(e);
     // Make sure that the exception is raised.
-    ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_NE(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
 
     ASSERT_EQ(__llvm_libc::fesetenv(FE_DFL_ENV), 0);
     // Setting the default env should clear all exceptions.
-    ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+    ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT) & e, 0);
   }
 
   ASSERT_EQ(__llvm_libc::fesetround(FE_DOWNWARD), 0);
   ASSERT_EQ(__llvm_libc::fesetenv(FE_DFL_ENV), 0);
   // Setting the default env should set rounding mode to FE_TONEAREST.
   int rm = __llvm_libc::fegetround();
   EXPECT_EQ(rm, FE_TONEAREST);
 }

libc/test/src/math/CeilTest.h

template <typename T> class CeilTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*CeilFunc)(T);
 
   void testSpecialNumbers(CeilFunc func) {
     EXPECT_FP_EQ(zero, func(zero));
-    EXPECT_FP_EQ(negZero, func(negZero));
+    EXPECT_FP_EQ(neg_zero, func(neg_zero));
 
     EXPECT_FP_EQ(inf, func(inf));
-    EXPECT_FP_EQ(negInf, func(negInf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf));
 
     EXPECT_FP_EQ(aNaN, func(aNaN));
   }
 
   void testRoundedNumbers(CeilFunc func) {
     EXPECT_FP_EQ(T(1.0), func(T(1.0)));
     EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
     EXPECT_FP_EQ(T(10.0), func(T(10.0)));

libc/test/src/math/CopySignTest.h

 
 public:
   typedef T (*CopySignFunc)(T, T);
 
   void testSpecialNumbers(CopySignFunc func) {
     EXPECT_FP_EQ(aNaN, func(aNaN, -1.0));
     EXPECT_FP_EQ(aNaN, func(aNaN, 1.0));
 
-    EXPECT_FP_EQ(negInf, func(inf, -1.0));
-    EXPECT_FP_EQ(inf, func(negInf, 1.0));
+    EXPECT_FP_EQ(neg_inf, func(inf, -1.0));
+    EXPECT_FP_EQ(inf, func(neg_inf, 1.0));
 
-    EXPECT_FP_EQ(negZero, func(zero, -1.0));
-    EXPECT_FP_EQ(zero, func(negZero, 1.0));
+    EXPECT_FP_EQ(neg_zero, func(zero, -1.0));
+    EXPECT_FP_EQ(zero, func(neg_zero, 1.0));
   }
 
   void testRange(CopySignFunc func) {
     constexpr UIntType count = 10000000;
     constexpr UIntType step = UIntType(-1) / count;
     for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))

libc/test/src/math/FAbsTest.h

 
 public:
   typedef T (*FabsFunc)(T);
 
   void testSpecialNumbers(FabsFunc func) {
     EXPECT_FP_EQ(aNaN, func(aNaN));
 
     EXPECT_FP_EQ(inf, func(inf));
-    EXPECT_FP_EQ(inf, func(negInf));
+    EXPECT_FP_EQ(inf, func(neg_inf));
 
     EXPECT_FP_EQ(zero, func(zero));
-    EXPECT_FP_EQ(zero, func(negZero));
+    EXPECT_FP_EQ(zero, func(neg_zero));
   }
 
   void testRange(FabsFunc func) {
     constexpr UIntType count = 10000000;
     constexpr UIntType step = UIntType(-1) / count;
     for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))

libc/test/src/math/FDimTest.h

 class FDimTestTemplate : public __llvm_libc::testing::Test {
 public:
   using FuncPtr = T (*)(T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 
   void testNaNArg(FuncPtr func) {
     EXPECT_FP_EQ(nan, func(nan, inf));
-    EXPECT_FP_EQ(nan, func(negInf, nan));
+    EXPECT_FP_EQ(nan, func(neg_inf, nan));
     EXPECT_FP_EQ(nan, func(nan, zero));
-    EXPECT_FP_EQ(nan, func(negZero, nan));
+    EXPECT_FP_EQ(nan, func(neg_zero, nan));
     EXPECT_FP_EQ(nan, func(nan, T(-1.2345)));
     EXPECT_FP_EQ(nan, func(T(1.2345), nan));
     EXPECT_FP_EQ(func(nan, nan), nan);
   }
 
   void testInfArg(FuncPtr func) {
-    EXPECT_FP_EQ(zero, func(negInf, inf));
+    EXPECT_FP_EQ(zero, func(neg_inf, inf));
     EXPECT_FP_EQ(inf, func(inf, zero));
-    EXPECT_FP_EQ(zero, func(negZero, inf));
+    EXPECT_FP_EQ(zero, func(neg_zero, inf));
     EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
     EXPECT_FP_EQ(zero, func(T(-1.2345), inf));
   }
 
   void testNegInfArg(FuncPtr func) {
-    EXPECT_FP_EQ(inf, func(inf, negInf));
-    EXPECT_FP_EQ(zero, func(negInf, zero));
-    EXPECT_FP_EQ(inf, func(negZero, negInf));
-    EXPECT_FP_EQ(zero, func(negInf, T(-1.2345)));
-    EXPECT_FP_EQ(inf, func(T(1.2345), negInf));
+    EXPECT_FP_EQ(inf, func(inf, neg_inf));
+    EXPECT_FP_EQ(zero, func(neg_inf, zero));
+    EXPECT_FP_EQ(inf, func(neg_zero, neg_inf));
+    EXPECT_FP_EQ(zero, func(neg_inf, T(-1.2345)));
+    EXPECT_FP_EQ(inf, func(T(1.2345), neg_inf));
   }
 
   void testBothZero(FuncPtr func) {
     EXPECT_FP_EQ(zero, func(zero, zero));
-    EXPECT_FP_EQ(zero, func(zero, negZero));
-    EXPECT_FP_EQ(zero, func(negZero, zero));
-    EXPECT_FP_EQ(zero, func(negZero, negZero));
+    EXPECT_FP_EQ(zero, func(zero, neg_zero));
+    EXPECT_FP_EQ(zero, func(neg_zero, zero));
+    EXPECT_FP_EQ(zero, func(neg_zero, neg_zero));
   }
 
   void testInRange(FuncPtr func) {
     constexpr UIntType count = 10000001;
     constexpr UIntType step = UIntType(-1) / count;
     for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
          ++i, v += step, w -= step) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       if (isnan(x) || isinf(x))
         continue;
       if (isnan(y) || isinf(y))
         continue;
 
       if (x > y) {
         EXPECT_FP_EQ(x - y, func(x, y));
       } else {
         EXPECT_FP_EQ(zero, func(x, y));
       }
     }
   }
 
 private:
   // constexpr does not work on FPBits yet, so we cannot have these constants as
   // static.
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::buildNaN(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
-  const T negInf = T(__llvm_libc::fputil::FPBits<T>::negInf());
+  const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
-  const T negZero = T(__llvm_libc::fputil::FPBits<T>::negZero());
+  const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
 };

libc/test/src/math/FMaxTest.h

template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*FMaxFunc)(T, T);
 
   void testNaN(FMaxFunc func) {
     EXPECT_FP_EQ(inf, func(aNaN, inf));
-    EXPECT_FP_EQ(negInf, func(negInf, aNaN));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN));
     EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
     EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
     EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
     EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
   }
 
   void testInfArg(FMaxFunc func) {
-    EXPECT_FP_EQ(inf, func(negInf, inf));
+    EXPECT_FP_EQ(inf, func(neg_inf, inf));
     EXPECT_FP_EQ(inf, func(inf, 0.0));
     EXPECT_FP_EQ(inf, func(-0.0, inf));
     EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
     EXPECT_FP_EQ(inf, func(T(-1.2345), inf));
   }
 
   void testNegInfArg(FMaxFunc func) {
-    EXPECT_FP_EQ(inf, func(inf, negInf));
-    EXPECT_FP_EQ(0.0, func(negInf, 0.0));
-    EXPECT_FP_EQ(-0.0, func(-0.0, negInf));
-    EXPECT_FP_EQ(T(-1.2345), func(negInf, T(-1.2345)));
-    EXPECT_FP_EQ(T(1.2345), func(T(1.2345), negInf));
+    EXPECT_FP_EQ(inf, func(inf, neg_inf));
+    EXPECT_FP_EQ(0.0, func(neg_inf, 0.0));
+    EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf));
+    EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345)));
+    EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf));
   }
 
   void testBothZero(FMaxFunc func) {
     EXPECT_FP_EQ(0.0, func(0.0, 0.0));
     EXPECT_FP_EQ(0.0, func(-0.0, 0.0));
     EXPECT_FP_EQ(0.0, func(0.0, -0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
   }

libc/test/src/math/FMinTest.h

template <typename T> class FMinTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*FMinFunc)(T, T);
 
   void testNaN(FMinFunc func) {
     EXPECT_FP_EQ(inf, func(aNaN, inf));
-    EXPECT_FP_EQ(negInf, func(negInf, aNaN));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN));
     EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
     EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
     EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
     EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
   }
 
   void testInfArg(FMinFunc func) {
-    EXPECT_FP_EQ(negInf, func(negInf, inf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf, inf));
     EXPECT_FP_EQ(0.0, func(inf, 0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, inf));
     EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
     EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf));
   }
 
   void testNegInfArg(FMinFunc func) {
-    EXPECT_FP_EQ(negInf, func(inf, negInf));
-    EXPECT_FP_EQ(negInf, func(negInf, 0.0));
-    EXPECT_FP_EQ(negInf, func(-0.0, negInf));
-    EXPECT_FP_EQ(negInf, func(negInf, T(-1.2345)));
-    EXPECT_FP_EQ(negInf, func(T(1.2345), negInf));
+    EXPECT_FP_EQ(neg_inf, func(inf, neg_inf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0));
+    EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345)));
+    EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf));
   }
 
   void testBothZero(FMinFunc func) {
     EXPECT_FP_EQ(0.0, func(0.0, 0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
     EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
   }

libc/test/src/math/FloorTest.h

template <typename T> class FloorTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*FloorFunc)(T);
 
   void testSpecialNumbers(FloorFunc func) {
     EXPECT_FP_EQ(zero, func(zero));
-    EXPECT_FP_EQ(negZero, func(negZero));
+    EXPECT_FP_EQ(neg_zero, func(neg_zero));
 
     EXPECT_FP_EQ(inf, func(inf));
-    EXPECT_FP_EQ(negInf, func(negInf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf));
 
     EXPECT_FP_EQ(aNaN, func(aNaN));
   }
 
   void testRoundedNumbers(FloorFunc func) {
     EXPECT_FP_EQ(T(1.0), func(T(1.0)));
     EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
     EXPECT_FP_EQ(T(10.0), func(T(10.0)));

libc/test/src/math/FmaTest.h

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T>
 class FmaTestTemplate : public __llvm_libc::testing::Test {
 private:
   using Func = T (*)(T, T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::buildNaN(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
-  const T negInf = T(__llvm_libc::fputil::FPBits<T>::negInf());
+  const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
-  const T negZero = T(__llvm_libc::fputil::FPBits<T>::negZero());
+  const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
 
   UIntType getRandomBitPattern() {
     UIntType bits{0};
     for (UIntType i = 0; i < sizeof(UIntType) / 2; ++i) {
       bits =
           (bits << 2) + static_cast<uint16_t>(__llvm_libc::testutils::rand());
     }
     return bits;
   }
 
 public:
   void testSpecialNumbers(Func func) {
     EXPECT_FP_EQ(func(zero, zero, zero), zero);
-    EXPECT_FP_EQ(func(zero, negZero, negZero), negZero);
+    EXPECT_FP_EQ(func(zero, neg_zero, neg_zero), neg_zero);
     EXPECT_FP_EQ(func(inf, inf, zero), inf);
-    EXPECT_FP_EQ(func(negInf, inf, negInf), negInf);
+    EXPECT_FP_EQ(func(neg_inf, inf, neg_inf), neg_inf);
     EXPECT_FP_EQ(func(inf, zero, zero), nan);
-    EXPECT_FP_EQ(func(inf, negInf, inf), nan);
+    EXPECT_FP_EQ(func(inf, neg_inf, inf), nan);
     EXPECT_FP_EQ(func(nan, zero, inf), nan);
-    EXPECT_FP_EQ(func(inf, negInf, nan), nan);
+    EXPECT_FP_EQ(func(inf, neg_inf, nan), nan);
 
     // Test underflow rounding up.
-    EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::minSubnormal)),
-                      T(FPBits(FPBits::minSubnormal))),
+    EXPECT_FP_EQ(func(T(0.5), T(FPBits(FPBits::MIN_SUBNORMAL)),
+                      T(FPBits(FPBits::MIN_SUBNORMAL))),
                  T(FPBits(UIntType(2))));
     // Test underflow rounding down.
-    T v = T(FPBits(FPBits::minNormal + UIntType(1)));
-    EXPECT_FP_EQ(
-        func(T(1) / T(FPBits::minNormal << 1), v, T(FPBits(FPBits::minNormal))),
+    T v = T(FPBits(FPBits::MIN_NORMAL + UIntType(1)));
+    EXPECT_FP_EQ(func(T(1) / T(FPBits::MIN_NORMAL << 1), v,
+                      T(FPBits(FPBits::MIN_NORMAL))),
                  v);
     // Test overflow.
-    T z = T(FPBits(FPBits::maxNormal));
+    T z = T(FPBits(FPBits::MAX_NORMAL));
     EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z);
   }
 
   void testSubnormalRange(Func func) {
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
-        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
-    for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
-         v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
+        (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+    for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
+         v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
          v += step, w -= step) {
       T x = T(FPBits(getRandomBitPattern())), y = T(FPBits(v)),
         z = T(FPBits(w));
       T result = func(x, y, z);
       mpfr::TernaryInput<T> input{x, y, z};
       ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5);
     }
   }
 
   void testNormalRange(Func func) {
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
-    for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
-         v <= FPBits::maxNormal && w >= FPBits::minNormal;
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+    for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
+         v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
          v += step, w -= step) {
       T x = T(FPBits(v)), y = T(FPBits(w)),
         z = T(FPBits(getRandomBitPattern()));
       T result = func(x, y, z);
       mpfr::TernaryInput<T> input{x, y, z};
       ASSERT_MPFR_MATCH(mpfr::Operation::Fma, input, result, 0.5);
     }
   }
 };
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H

libc/test/src/math/FrexpTest.h

 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
   static constexpr UIntType HiddenBit =
-      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::value;
+      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
 
 public:
   typedef T (*FrexpFunc)(T, int *);
 
   void testSpecialNumbers(FrexpFunc func) {
     int exponent;
     ASSERT_FP_EQ(aNaN, func(aNaN, &exponent));
     ASSERT_FP_EQ(inf, func(inf, &exponent));
-    ASSERT_FP_EQ(negInf, func(negInf, &exponent));
+    ASSERT_FP_EQ(neg_inf, func(neg_inf, &exponent));
 
     ASSERT_FP_EQ(0.0, func(0.0, &exponent));
     ASSERT_EQ(exponent, 0);
 
     ASSERT_FP_EQ(-0.0, func(-0.0, &exponent));
     ASSERT_EQ(exponent, 0);
   }
 

libc/test/src/math/HypotTest.h

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T>
 class HypotTestTemplate : public __llvm_libc::testing::Test {
 private:
   using Func = T (*)(T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::buildNaN(1));
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
-  const T negInf = T(__llvm_libc::fputil::FPBits<T>::negInf());
+  const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
-  const T negZero = T(__llvm_libc::fputil::FPBits<T>::negZero());
+  const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
 
 public:
   void testSpecialNumbers(Func func) {
     EXPECT_FP_EQ(func(inf, nan), inf);
-    EXPECT_FP_EQ(func(nan, negInf), inf);
+    EXPECT_FP_EQ(func(nan, neg_inf), inf);
     EXPECT_FP_EQ(func(zero, inf), inf);
-    EXPECT_FP_EQ(func(negInf, negZero), inf);
+    EXPECT_FP_EQ(func(neg_inf, neg_zero), inf);
 
     EXPECT_FP_EQ(func(nan, nan), nan);
     EXPECT_FP_EQ(func(nan, zero), nan);
-    EXPECT_FP_EQ(func(negZero, nan), nan);
+    EXPECT_FP_EQ(func(neg_zero, nan), nan);
 
-    EXPECT_FP_EQ(func(negZero, zero), zero);
+    EXPECT_FP_EQ(func(neg_zero, zero), zero);
   }
 
   void testSubnormalRange(Func func) {
     constexpr UIntType count = 1000001;
     for (unsigned scale = 0; scale < 4; ++scale) {
-      UIntType maxValue = FPBits::maxSubnormal << scale;
-      UIntType step = (maxValue - FPBits::minSubnormal) / count;
+      UIntType maxValue = FPBits::MAX_SUBNORMAL << scale;
+      UIntType step = (maxValue - FPBits::MIN_SUBNORMAL) / count;
       for (int signs = 0; signs < 4; ++signs) {
-        for (UIntType v = FPBits::minSubnormal, w = maxValue;
-             v <= maxValue && w >= FPBits::minSubnormal; v += step, w -= step) {
+        for (UIntType v = FPBits::MIN_SUBNORMAL, w = maxValue;
+             v <= maxValue && w >= FPBits::MIN_SUBNORMAL;
+             v += step, w -= step) {
           T x = T(FPBits(v)), y = T(FPBits(w));
           if (signs % 2 == 1) {
             x = -x;
           }
           if (signs >= 2) {
             y = -y;
           }
 
           T result = func(x, y);
           mpfr::BinaryInput<T> input{x, y};
           ASSERT_MPFR_MATCH(mpfr::Operation::Hypot, input, result, 0.5);
         }
       }
     }
   }
 
   void testNormalRange(Func func) {
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
     for (int signs = 0; signs < 4; ++signs) {
-      for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
-           v <= FPBits::maxNormal && w >= FPBits::minNormal;
+      for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
+           v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
            v += step, w -= step) {
         T x = T(FPBits(v)), y = T(FPBits(w));
         if (signs % 2 == 1) {
           x = -x;
         }
         if (signs >= 2) {
           y = -y;
         }

libc/test/src/math/ILogbTest.h

 
 class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
 public:
   template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
 
   template <typename T>
   void testSpecialNumbers(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::zero())));
-    EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::negZero())));
+    EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero())));
 
     EXPECT_EQ(FP_ILOGBNAN,
-              func(T(__llvm_libc::fputil::FPBits<T>::buildNaN(1))));
+              func(T(__llvm_libc::fputil::FPBits<T>::build_nan(1))));
 
     EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::inf())));
-    EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::negInf())));
+    EXPECT_EQ(INT_MAX, func(T(__llvm_libc::fputil::FPBits<T>::neg_inf())));
   }
 
   template <typename T> void testPowersOfTwo(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(0, func(T(1.0)));
     EXPECT_EQ(0, func(T(-1.0)));
 
     EXPECT_EQ(1, func(T(2.0)));
     EXPECT_EQ(1, func(T(-2.0)));
public:
   }
 
   template <typename T>
   void testSubnormalRange(typename ILogbFunc<T>::Func func) {
     using FPBits = __llvm_libc::fputil::FPBits<T>;
     using UIntType = typename FPBits::UIntType;
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
-        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
-    for (UIntType v = FPBits::minSubnormal; v <= FPBits::maxSubnormal;
+        (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+    for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL;
          v += step) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0)
         continue;
 
       int exponent;
       __llvm_libc::fputil::frexp(x, exponent);
       ASSERT_EQ(exponent, func(x) + 1);
     }
   }
 
   template <typename T> void testNormalRange(typename ILogbFunc<T>::Func func) {
     using FPBits = __llvm_libc::fputil::FPBits<T>;
     using UIntType = typename FPBits::UIntType;
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
-    for (UIntType v = FPBits::minNormal; v <= FPBits::maxNormal; v += step) {
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+    for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += step) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0)
         continue;
 
       int exponent;
       __llvm_libc::fputil::frexp(x, exponent);
       ASSERT_EQ(exponent, func(x) + 1);
     }
   }
 };
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H

libc/test/src/math/LdExpTest.h

 #include <stdint.h>
 
 template <typename T>
 class LdExpTestTemplate : public __llvm_libc::testing::Test {
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using NormalFloat = __llvm_libc::fputil::NormalFloat<T>;
   using UIntType = typename FPBits::UIntType;
   static constexpr UIntType mantissaWidth =
-      __llvm_libc::fputil::MantissaWidth<T>::value;
+      __llvm_libc::fputil::MantissaWidth<T>::VALUE;
   // A normalized mantissa to be used with tests.
-  static constexpr UIntType mantissa = NormalFloat::one + 0x1234;
+  static constexpr UIntType mantissa = NormalFloat::ONE + 0x1234;
 
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
-  const T negZero = T(__llvm_libc::fputil::FPBits<T>::negZero());
+  const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
-  const T negInf = T(__llvm_libc::fputil::FPBits<T>::negInf());
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::buildNaN(1));
+  const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
 
 public:
   typedef T (*LdExpFunc)(T, int);
 
   void testSpecialNumbers(LdExpFunc func) {
     int expArray[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
     for (int exp : expArray) {
       ASSERT_FP_EQ(zero, func(zero, exp));
-      ASSERT_FP_EQ(negZero, func(negZero, exp));
+      ASSERT_FP_EQ(neg_zero, func(neg_zero, exp));
       ASSERT_FP_EQ(inf, func(inf, exp));
-      ASSERT_FP_EQ(negInf, func(negInf, exp));
+      ASSERT_FP_EQ(neg_inf, func(neg_inf, exp));
       ASSERT_FP_EQ(nan, func(nan, exp));
     }
   }
 
   void testPowersOfTwo(LdExpFunc func) {
     int32_t expArray[5] = {1, 2, 3, 4, 5};
     int32_t valArray[6] = {1, 2, 4, 8, 16, 32};
     for (int32_t exp : expArray) {
       for (int32_t val : valArray) {
         ASSERT_FP_EQ(T(val << exp), func(T(val), exp));
         ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp));
       }
     }
   }
 
   void testOverflow(LdExpFunc func) {
-    NormalFloat x(FPBits::maxExponent - 10, NormalFloat::one + 0xF00BA, 0);
+    NormalFloat x(FPBits::MAX_EXPONENT - 10, NormalFloat::ONE + 0xF00BA, 0);
     for (int32_t exp = 10; exp < 100; ++exp) {
       ASSERT_FP_EQ(inf, func(T(x), exp));
-      ASSERT_FP_EQ(negInf, func(-T(x), exp));
+      ASSERT_FP_EQ(neg_inf, func(-T(x), exp));
     }
   }
 
   void testUnderflowToZeroOnNormal(LdExpFunc func) {
     // In this test, we pass a normal nubmer to func and expect zero
     // to be returned due to underflow.
-    int32_t baseExponent = FPBits::exponentBias + mantissaWidth;
+    int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth;
     int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
                           baseExponent + 2, baseExponent + 1};
     T x = NormalFloat(0, mantissa, 0);
     for (int32_t exp : expArray) {
-      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : negZero);
+      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
     }
   }
 
   void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
     // In this test, we pass a normal nubmer to func and expect zero
     // to be returned due to underflow.
-    int32_t baseExponent = FPBits::exponentBias + mantissaWidth;
+    int32_t baseExponent = FPBits::EXPONENT_BIAS + mantissaWidth;
     int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
                           baseExponent + 2, baseExponent + 1};
-    T x = NormalFloat(-FPBits::exponentBias, mantissa, 0);
+    T x = NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0);
     for (int32_t exp : expArray) {
-      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : negZero);
+      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : neg_zero);
     }
   }
 
   void testNormalOperation(LdExpFunc func) {
     T valArray[] = {
         // Normal numbers
         NormalFloat(100, mantissa, 0), NormalFloat(-100, mantissa, 0),
         NormalFloat(100, mantissa, 1), NormalFloat(-100, mantissa, 1),
         // Subnormal numbers
-        NormalFloat(-FPBits::exponentBias, mantissa, 0),
-        NormalFloat(-FPBits::exponentBias, mantissa, 1)};
+        NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 0),
+        NormalFloat(-FPBits::EXPONENT_BIAS, mantissa, 1)};
     for (int32_t exp = 0; exp <= static_cast<int32_t>(mantissaWidth); ++exp) {
       for (T x : valArray) {
         // We compare the result of ldexp with the result
         // of the native multiplication/division instruction.
         ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp));
         ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp));
       }
     }
 
     // Normal which trigger mantissa overflow.
-    T x = NormalFloat(-FPBits::exponentBias + 1, 2 * NormalFloat::one - 1, 0);
+    T x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, 2 * NormalFloat::ONE - 1, 0);
     ASSERT_FP_EQ(func(x, -1), x / 2);
     ASSERT_FP_EQ(func(-x, -1), -x / 2);
 
     // Start with a normal number high exponent but pass a very low number for
     // exp. The result should be a subnormal number.
-    x = NormalFloat(FPBits::exponentBias, NormalFloat::one, 0);
-    int exp = -FPBits::maxExponent - 5;
+    x = NormalFloat(FPBits::EXPONENT_BIAS, NormalFloat::ONE, 0);
+    int exp = -FPBits::MAX_EXPONENT - 5;
     T result = func(x, exp);
     FPBits resultBits(result);
-    ASSERT_FALSE(resultBits.isZero());
+    ASSERT_FALSE(resultBits.is_zero());
     // Verify that the result is indeed subnormal.
-    ASSERT_EQ(resultBits.getUnbiasedExponent(), uint16_t(0));
+    ASSERT_EQ(resultBits.get_unbiased_exponent(), uint16_t(0));
     // But if the exp is so less that normalization leads to zero, then
     // the result should be zero.
-    result = func(x, -FPBits::maxExponent - int(mantissaWidth) - 5);
-    ASSERT_TRUE(FPBits(result).isZero());
+    result = func(x, -FPBits::MAX_EXPONENT - int(mantissaWidth) - 5);
+    ASSERT_TRUE(FPBits(result).is_zero());
 
     // Start with a subnormal number but pass a very high number for exponent.
     // The result should not be infinity.
-    x = NormalFloat(-FPBits::exponentBias + 1, NormalFloat::one >> 10, 0);
-    exp = FPBits::maxExponent + 5;
-    ASSERT_FALSE(FPBits(func(x, exp)).isInf());
+    x = NormalFloat(-FPBits::EXPONENT_BIAS + 1, NormalFloat::ONE >> 10, 0);
+    exp = FPBits::MAX_EXPONENT + 5;
+    ASSERT_FALSE(FPBits(func(x, exp)).is_inf());
     // But if the exp is large enough to oversome than the normalization shift,
     // then it should result in infinity.
-    exp = FPBits::maxExponent + 15;
+    exp = FPBits::MAX_EXPONENT + 15;
     ASSERT_FP_EQ(func(x, exp), inf);
   }
 };
 
 #define LIST_LDEXP_TESTS(T, func)                                              \
   using LlvmLibcLdExpTest = LdExpTestTemplate<T>;                              \
   TEST_F(LlvmLibcLdExpTest, SpecialNumbers) { testSpecialNumbers(&func); }     \
   TEST_F(LlvmLibcLdExpTest, PowersOfTwo) { testPowersOfTwo(&func); }           \

libc/test/src/math/LogbTest.h

 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T> class LogbTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
   static constexpr UIntType HiddenBit =
-      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::value;
+      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
 
 public:
   typedef T (*LogbFunc)(T);
 
   void testSpecialNumbers(LogbFunc func) {
     ASSERT_FP_EQ(aNaN, func(aNaN));
     ASSERT_FP_EQ(inf, func(inf));
-    ASSERT_FP_EQ(inf, func(negInf));
-    ASSERT_FP_EQ(negInf, func(0.0));
-    ASSERT_FP_EQ(negInf, func(-0.0));
+    ASSERT_FP_EQ(inf, func(neg_inf));
+    ASSERT_FP_EQ(neg_inf, func(0.0));
+    ASSERT_FP_EQ(neg_inf, func(-0.0));
   }
 
   void testPowersOfTwo(LogbFunc func) {
     EXPECT_FP_EQ(T(0.0), func(T(1.0)));
     EXPECT_FP_EQ(T(0.0), func(T(-1.0)));
 
     EXPECT_FP_EQ(T(1.0), func(T(2.0)));
     EXPECT_FP_EQ(T(1.0), func(T(-2.0)));

libc/test/src/math/ModfTest.h

 public:
   typedef T (*ModfFunc)(T, T *);
 
   void testSpecialNumbers(ModfFunc func) {
     T integral;
 
     EXPECT_FP_EQ(zero, func(zero, &integral));
     EXPECT_FP_EQ(integral, zero);
-    EXPECT_FP_EQ(negZero, func(negZero, &integral));
-    EXPECT_FP_EQ(integral, negZero);
+    EXPECT_FP_EQ(neg_zero, func(neg_zero, &integral));
+    EXPECT_FP_EQ(integral, neg_zero);
 
     EXPECT_FP_EQ(zero, func(inf, &integral));
     EXPECT_FP_EQ(inf, integral);
-    EXPECT_FP_EQ(negZero, func(negInf, &integral));
-    EXPECT_FP_EQ(negInf, integral);
+    EXPECT_FP_EQ(neg_zero, func(neg_inf, &integral));
+    EXPECT_FP_EQ(neg_inf, integral);
 
     EXPECT_FP_EQ(aNaN, func(aNaN, &integral));
   }
 
   void testIntegers(ModfFunc func) {
     T integral;
 
     EXPECT_FP_EQ(T(0.0), func(T(1.0), &integral));

libc/test/src/math/NextAfterTest.h

 
 template <typename T>
 class NextAfterTestTemplate : public __llvm_libc::testing::Test {
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
   using UIntType = typename FPBits::UIntType;
 
   static constexpr int bitWidthOfType =
-      __llvm_libc::fputil::FloatProperties<T>::bitWidth;
+      __llvm_libc::fputil::FloatProperties<T>::BIT_WIDTH;
 
   const T zero = T(FPBits::zero());
-  const T negZero = T(FPBits::negZero());
+  const T neg_zero = T(FPBits::neg_zero());
   const T inf = T(FPBits::inf());
-  const T negInf = T(FPBits::negInf());
-  const T nan = T(FPBits::buildNaN(1));
-  const UIntType minSubnormal = FPBits::minSubnormal;
-  const UIntType maxSubnormal = FPBits::maxSubnormal;
-  const UIntType minNormal = FPBits::minNormal;
-  const UIntType maxNormal = FPBits::maxNormal;
+  const T neg_inf = T(FPBits::neg_inf());
+  const T nan = T(FPBits::build_nan(1));
+  const UIntType MIN_SUBNORMAL = FPBits::MIN_SUBNORMAL;
+  const UIntType MAX_SUBNORMAL = FPBits::MAX_SUBNORMAL;
+  const UIntType MIN_NORMAL = FPBits::MIN_NORMAL;
+  const UIntType MAX_NORMAL = FPBits::MAX_NORMAL;
 
 public:
   typedef T (*NextAfterFunc)(T, T);
 
   void testNaN(NextAfterFunc func) {
     ASSERT_FP_EQ(func(nan, 0), nan);
     ASSERT_FP_EQ(func(0, nan), nan);
   }
 
   void testBoundaries(NextAfterFunc func) {
-    ASSERT_FP_EQ(func(zero, negZero), negZero);
-    ASSERT_FP_EQ(func(negZero, zero), zero);
+    ASSERT_FP_EQ(func(zero, neg_zero), neg_zero);
+    ASSERT_FP_EQ(func(neg_zero, zero), zero);
 
-    // 'from' is zero|negZero.
+    // 'from' is zero|neg_zero.
     T x = zero;
     T result = func(x, T(1));
     UIntType expectedBits = 1;
     T expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, T(-1));
     expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
-    x = negZero;
+    x = neg_zero;
     result = func(x, 1);
     expectedBits = 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, -1);
     expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is max subnormal value.
-    x = *reinterpret_cast<const T *>(&maxSubnormal);
+    x = *reinterpret_cast<const T *>(&MAX_SUBNORMAL);
     result = func(x, 1);
-    expected = *reinterpret_cast<const T *>(&minNormal);
+    expected = *reinterpret_cast<const T *>(&MIN_NORMAL);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, 0);
-    expectedBits = maxSubnormal - 1;
+    expectedBits = MAX_SUBNORMAL - 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     x = -x;
 
     result = func(x, -1);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minNormal;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, 0);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxSubnormal - 1;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL - 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is min subnormal value.
-    x = *reinterpret_cast<const T *>(&minSubnormal);
+    x = *reinterpret_cast<const T *>(&MIN_SUBNORMAL);
     result = func(x, 1);
-    expectedBits = minSubnormal + 1;
+    expectedBits = MIN_SUBNORMAL + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, 0), 0);
 
     x = -x;
     result = func(x, -1);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minSubnormal + 1;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_SUBNORMAL + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, 0), T(-0.0));
 
     // 'from' is min normal.
-    x = *reinterpret_cast<const T *>(&minNormal);
+    x = *reinterpret_cast<const T *>(&MIN_NORMAL);
     result = func(x, 0);
-    expectedBits = maxSubnormal;
+    expectedBits = MAX_SUBNORMAL;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, inf);
-    expectedBits = minNormal + 1;
+    expectedBits = MIN_NORMAL + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     x = -x;
     result = func(x, 0);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxSubnormal;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_SUBNORMAL;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, -inf);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + minNormal + 1;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MIN_NORMAL + 1;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is max normal and 'to' is infinity.
-    x = *reinterpret_cast<const T *>(&maxNormal);
+    x = *reinterpret_cast<const T *>(&MAX_NORMAL);
     result = func(x, inf);
     ASSERT_FP_EQ(result, inf);
 
     result = func(-x, -inf);
     ASSERT_FP_EQ(result, -inf);
 
     // 'from' is infinity.
     x = inf;
     result = func(x, 0);
-    expectedBits = maxNormal;
+    expectedBits = MAX_NORMAL;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, inf), inf);
 
-    x = negInf;
+    x = neg_inf;
     result = func(x, 0);
-    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + maxNormal;
+    expectedBits = (UIntType(1) << (bitWidthOfType - 1)) + MAX_NORMAL;
     expected = *reinterpret_cast<T *>(&expectedBits);
     ASSERT_FP_EQ(result, expected);
-    ASSERT_FP_EQ(func(x, negInf), negInf);
+    ASSERT_FP_EQ(func(x, neg_inf), neg_inf);
 
     // 'from' is a power of 2.
     x = T(32.0);
     result = func(x, 0);
     FPBits xBits = FPBits(x);
     FPBits resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.getUnbiasedExponent(),
-              uint16_t(xBits.getUnbiasedExponent() - 1));
-    ASSERT_EQ(resultBits.getMantissa(),
-              (UIntType(1) << MantissaWidth::value) - 1);
+    ASSERT_EQ(resultBits.get_unbiased_exponent(),
+              uint16_t(xBits.get_unbiased_exponent() - 1));
+    ASSERT_EQ(resultBits.get_mantissa(),
+              (UIntType(1) << MantissaWidth::VALUE) - 1);
 
     result = func(x, T(33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.getUnbiasedExponent(), xBits.getUnbiasedExponent());
-    ASSERT_EQ(resultBits.getMantissa(), xBits.getMantissa() + UIntType(1));
+    ASSERT_EQ(resultBits.get_unbiased_exponent(),
+              xBits.get_unbiased_exponent());
+    ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1));
 
     x = -x;
 
     result = func(x, 0);
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.getUnbiasedExponent(),
-              uint16_t(xBits.getUnbiasedExponent() - 1));
-    ASSERT_EQ(resultBits.getMantissa(),
-              (UIntType(1) << MantissaWidth::value) - 1);
+    ASSERT_EQ(resultBits.get_unbiased_exponent(),
+              uint16_t(xBits.get_unbiased_exponent() - 1));
+    ASSERT_EQ(resultBits.get_mantissa(),
+              (UIntType(1) << MantissaWidth::VALUE) - 1);
 
     result = func(x, T(-33.0));
     resultBits = FPBits(result);
-    ASSERT_EQ(resultBits.getUnbiasedExponent(), xBits.getUnbiasedExponent());
-    ASSERT_EQ(resultBits.getMantissa(), xBits.getMantissa() + UIntType(1));
+    ASSERT_EQ(resultBits.get_unbiased_exponent(),
+              xBits.get_unbiased_exponent());
+    ASSERT_EQ(resultBits.get_mantissa(), xBits.get_mantissa() + UIntType(1));
   }
 };
 
 #define LIST_NEXTAFTER_TESTS(T, func)                                          \
   using LlvmLibcNextAfterTest = NextAfterTestTemplate<T>;                      \
   TEST_F(LlvmLibcNextAfterTest, TestNaN) { testNaN(&func); }                   \
   TEST_F(LlvmLibcNextAfterTest, TestBoundaries) { testBoundaries(&func); }
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H

libc/test/src/math/RIntTest.h

 public:
   typedef T (*RIntFunc)(T);
 
 private:
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 
   const T zero = T(FPBits::zero());
-  const T negZero = T(FPBits::negZero());
+  const T neg_zero = T(FPBits::neg_zero());
   const T inf = T(FPBits::inf());
-  const T negInf = T(FPBits::negInf());
-  const T nan = T(FPBits::buildNaN(1));
+  const T neg_inf = T(FPBits::neg_inf());
+  const T nan = T(FPBits::build_nan(1));
 
   static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
     switch (mode) {
     case FE_UPWARD:
       return mpfr::RoundingMode::Upward;
     case FE_DOWNWARD:
       return mpfr::RoundingMode::Downward;
     case FE_TOWARDZERO:
       return mpfr::RoundingMode::TowardZero;
     case FE_TONEAREST:
       return mpfr::RoundingMode::Nearest;
     default:
       __builtin_unreachable();
     }
   }
 
 public:
   void testSpecialNumbers(RIntFunc func) {
     for (int mode : roundingModes) {
-      __llvm_libc::fputil::setRound(mode);
+      __llvm_libc::fputil::set_round(mode);
       ASSERT_FP_EQ(inf, func(inf));
-      ASSERT_FP_EQ(negInf, func(negInf));
+      ASSERT_FP_EQ(neg_inf, func(neg_inf));
       ASSERT_FP_EQ(nan, func(nan));
       ASSERT_FP_EQ(zero, func(zero));
-      ASSERT_FP_EQ(negZero, func(negZero));
+      ASSERT_FP_EQ(neg_zero, func(neg_zero));
     }
   }
 
   void testRoundNumbers(RIntFunc func) {
     for (int mode : roundingModes) {
-      __llvm_libc::fputil::setRound(mode);
+      __llvm_libc::fputil::set_round(mode);
       mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
       ASSERT_FP_EQ(func(T(1.0)), mpfr::Round(T(1.0), mpfrMode));
       ASSERT_FP_EQ(func(T(-1.0)), mpfr::Round(T(-1.0), mpfrMode));
       ASSERT_FP_EQ(func(T(10.0)), mpfr::Round(T(10.0), mpfrMode));
       ASSERT_FP_EQ(func(T(-10.0)), mpfr::Round(T(-10.0), mpfrMode));
       ASSERT_FP_EQ(func(T(1234.0)), mpfr::Round(T(1234.0), mpfrMode));
       ASSERT_FP_EQ(func(T(-1234.0)), mpfr::Round(T(-1234.0), mpfrMode));
     }
   }
 
   void testFractions(RIntFunc func) {
     for (int mode : roundingModes) {
-      __llvm_libc::fputil::setRound(mode);
+      __llvm_libc::fputil::set_round(mode);
       mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
       ASSERT_FP_EQ(func(T(0.5)), mpfr::Round(T(0.5), mpfrMode));
       ASSERT_FP_EQ(func(T(-0.5)), mpfr::Round(T(-0.5), mpfrMode));
       ASSERT_FP_EQ(func(T(0.115)), mpfr::Round(T(0.115), mpfrMode));
       ASSERT_FP_EQ(func(T(-0.115)), mpfr::Round(T(-0.115), mpfrMode));
       ASSERT_FP_EQ(func(T(0.715)), mpfr::Round(T(0.715), mpfrMode));
       ASSERT_FP_EQ(func(T(-0.715)), mpfr::Round(T(-0.715), mpfrMode));
     }
   }
 
   void testSubnormalRange(RIntFunc func) {
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
-        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
-    for (UIntType i = FPBits::minSubnormal; i <= FPBits::maxSubnormal;
+        (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+    for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
          i += step) {
       T x = T(FPBits(i));
       for (int mode : roundingModes) {
-        __llvm_libc::fputil::setRound(mode);
+        __llvm_libc::fputil::set_round(mode);
         mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
         ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
       }
     }
   }
 
   void testNormalRange(RIntFunc func) {
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
-    for (UIntType i = FPBits::minNormal; i <= FPBits::maxNormal; i += step) {
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+    for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) {
       T x = T(FPBits(i));
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. We will skip them.
       if (isnan(x)) {
         continue;
       }
 
       for (int mode : roundingModes) {
-        __llvm_libc::fputil::setRound(mode);
+        __llvm_libc::fputil::set_round(mode);
         mpfr::RoundingMode mpfrMode = toMPFRRoundingMode(mode);
         ASSERT_FP_EQ(func(x), mpfr::Round(x, mpfrMode));
       }
     }
   }
 };
 
 #define LIST_RINT_TESTS(F, func)                                               \
   using LlvmLibcRIntTest = RIntTestTemplate<F>;                                \
   TEST_F(LlvmLibcRIntTest, specialNumbers) { testSpecialNumbers(&func); }      \
   TEST_F(LlvmLibcRIntTest, RoundNumbers) { testRoundNumbers(&func); }          \
   TEST_F(LlvmLibcRIntTest, Fractions) { testFractions(&func); }                \
   TEST_F(LlvmLibcRIntTest, SubnormalRange) { testSubnormalRange(&func); }      \
   TEST_F(LlvmLibcRIntTest, NormalRange) { testNormalRange(&func); }
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H

libc/test/src/math/RemQuoTest.h

 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T>
 class RemQuoTestTemplate : public __llvm_libc::testing::Test {
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 
   const T zero = T(__llvm_libc::fputil::FPBits<T>::zero());
-  const T negZero = T(__llvm_libc::fputil::FPBits<T>::negZero());
+  const T neg_zero = T(__llvm_libc::fputil::FPBits<T>::neg_zero());
   const T inf = T(__llvm_libc::fputil::FPBits<T>::inf());
-  const T negInf = T(__llvm_libc::fputil::FPBits<T>::negInf());
-  const T nan = T(__llvm_libc::fputil::FPBits<T>::buildNaN(1));
+  const T neg_inf = T(__llvm_libc::fputil::FPBits<T>::neg_inf());
+  const T nan = T(__llvm_libc::fputil::FPBits<T>::build_nan(1));
 
 public:
   typedef T (*RemQuoFunc)(T, T, int *);
 
   void testSpecialNumbers(RemQuoFunc func) {
     int quotient;
     T x, y;
 
     y = T(1.0);
     x = inf;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
-    x = negInf;
+    x = neg_inf;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
 
     x = T(1.0);
     y = zero;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
-    y = negZero;
+    y = neg_zero;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
 
     y = nan;
     x = T(1.0);
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
 
     y = T(1.0);
     x = nan;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
 
     x = nan;
     y = nan;
     EXPECT_FP_EQ(nan, func(x, y, &quotient));
 
     x = zero;
     y = T(1.0);
     EXPECT_FP_EQ(func(x, y, &quotient), zero);
 
-    x = negZero;
+    x = neg_zero;
     y = T(1.0);
-    EXPECT_FP_EQ(func(x, y, &quotient), negZero);
+    EXPECT_FP_EQ(func(x, y, &quotient), neg_zero);
 
     x = T(1.125);
     y = inf;
     EXPECT_FP_EQ(func(x, y, &quotient), x);
     EXPECT_EQ(quotient, 0);
   }
 
   void testEqualNumeratorAndDenominator(RemQuoFunc func) {
     T x = T(1.125), y = T(1.125);
     int q;
 
     // When the remainder is zero, the standard requires it to
     // have the same sign as x.
 
     EXPECT_FP_EQ(func(x, y, &q), zero);
     EXPECT_EQ(q, 1);
 
     EXPECT_FP_EQ(func(x, -y, &q), zero);
     EXPECT_EQ(q, -1);
 
-    EXPECT_FP_EQ(func(-x, y, &q), negZero);
+    EXPECT_FP_EQ(func(-x, y, &q), neg_zero);
     EXPECT_EQ(q, -1);
 
-    EXPECT_FP_EQ(func(-x, -y, &q), negZero);
+    EXPECT_FP_EQ(func(-x, -y, &q), neg_zero);
     EXPECT_EQ(q, 1);
   }
 
   void testSubnormalRange(RemQuoFunc func) {
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
-        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
-    for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
-         v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
+        (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+    for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
+         v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
          v += step, w -= step) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       mpfr::BinaryOutput<T> result;
       mpfr::BinaryInput<T> input{x, y};
       result.f = func(x, y, &result.i);
       ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
     }
   }
 
   void testNormalRange(RemQuoFunc func) {
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
-    for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
-         v <= FPBits::maxNormal && w >= FPBits::minNormal;
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+    for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
+         v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
          v += step, w -= step) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       mpfr::BinaryOutput<T> result;
       mpfr::BinaryInput<T> input{x, y};
       result.f = func(x, y, &result.i);
 
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. Hence we test for them separately.

libc/test/src/math/RoundTest.h

template <typename T> class RoundTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*RoundFunc)(T);
 
   void testSpecialNumbers(RoundFunc func) {
     EXPECT_FP_EQ(zero, func(zero));
-    EXPECT_FP_EQ(negZero, func(negZero));
+    EXPECT_FP_EQ(neg_zero, func(neg_zero));
 
     EXPECT_FP_EQ(inf, func(inf));
-    EXPECT_FP_EQ(negInf, func(negInf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf));
 
     EXPECT_FP_EQ(aNaN, func(aNaN));
   }
 
   void testRoundedNumbers(RoundFunc func) {
     EXPECT_FP_EQ(T(1.0), func(T(1.0)));
     EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
     EXPECT_FP_EQ(T(10.0), func(T(10.0)));

libc/test/src/math/RoundToIntegerTest.h

 public:
   typedef I (*RoundToIntegerFunc)(F);
 
 private:
   using FPBits = __llvm_libc::fputil::FPBits<F>;
   using UIntType = typename FPBits::UIntType;
 
   const F zero = F(__llvm_libc::fputil::FPBits<F>::zero());
-  const F negZero = F(__llvm_libc::fputil::FPBits<F>::negZero());
+  const F neg_zero = F(__llvm_libc::fputil::FPBits<F>::neg_zero());
   const F inf = F(__llvm_libc::fputil::FPBits<F>::inf());
-  const F negInf = F(__llvm_libc::fputil::FPBits<F>::negInf());
-  const F nan = F(__llvm_libc::fputil::FPBits<F>::buildNaN(1));
+  const F neg_inf = F(__llvm_libc::fputil::FPBits<F>::neg_inf());
+  const F nan = F(__llvm_libc::fputil::FPBits<F>::build_nan(1));
   static constexpr I IntegerMin = I(1) << (sizeof(I) * 8 - 1);
   static constexpr I IntegerMax = -(IntegerMin + 1);
 
   void testOneInput(RoundToIntegerFunc func, F input, I expected,
                     bool expectError) {
 #if math_errhandling & MATH_ERRNO
     errno = 0;
 #endif
 #if math_errhandling & MATH_ERREXCEPT
-    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
 #endif
 
     ASSERT_EQ(func(input), expected);
 
     if (expectError) {
 #if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT), FE_INVALID);
+      ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), FE_INVALID);
 #endif
 #if math_errhandling & MATH_ERRNO
       ASSERT_EQ(errno, EDOM);
 #endif
     } else {
 #if math_errhandling & MATH_ERREXCEPT
-      ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT), 0);
+      ASSERT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), 0);
 #endif
 #if math_errhandling & MATH_ERRNO
       ASSERT_EQ(errno, 0);
 #endif
     }
   }
 
   static inline mpfr::RoundingMode toMPFRRoundingMode(int mode) {
#endif
   }
 
 public:
   void SetUp() override {
 #if math_errhandling & MATH_ERREXCEPT
     // We will disable all exceptions so that the test will not
     // crash with SIGFPE. We can still use fetestexcept to check
     // if the appropriate flag was raised.
-    __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+    __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
 #endif
   }
 
   void doInfinityAndNaNTest(RoundToIntegerFunc func) {
     testOneInput(func, inf, IntegerMax, true);
-    testOneInput(func, negInf, IntegerMin, true);
+    testOneInput(func, neg_inf, IntegerMin, true);
     testOneInput(func, nan, IntegerMax, true);
   }
 
   void testInfinityAndNaN(RoundToIntegerFunc func) {
     if (TestModes) {
       for (int mode : roundingModes) {
-        __llvm_libc::fputil::setRound(mode);
+        __llvm_libc::fputil::set_round(mode);
         doInfinityAndNaNTest(func);
       }
     } else {
       doInfinityAndNaNTest(func);
     }
   }
 
   void doRoundNumbersTest(RoundToIntegerFunc func) {
     testOneInput(func, zero, I(0), false);
-    testOneInput(func, negZero, I(0), false);
+    testOneInput(func, neg_zero, I(0), false);
     testOneInput(func, F(1.0), I(1), false);
     testOneInput(func, F(-1.0), I(-1), false);
     testOneInput(func, F(10.0), I(10), false);
     testOneInput(func, F(-10.0), I(-10), false);
     testOneInput(func, F(1234.0), I(1234), false);
     testOneInput(func, F(-1234.0), I(-1234), false);
 
     // The rest of this this function compares with an equivalent MPFR function
     // which rounds floating point numbers to long values. There is no MPFR
     // function to round to long long or wider integer values. So, we will
     // the remaining tests only if the width of I less than equal to that of
     // long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr int exponentLimit = sizeof(I) * 8 - 1;
     // We start with 1.0 so that the implicit bit for x86 long doubles
     // is set.
     FPBits bits(F(1.0));
-    bits.setUnbiasedExponent(exponentLimit + FPBits::exponentBias);
-    bits.setSign(1);
-    bits.setMantissa(0);
+    bits.set_unbiased_exponent(exponentLimit + FPBits::EXPONENT_BIAS);
+    bits.set_sign(1);
+    bits.set_mantissa(0);
 
     F x = F(bits);
     long mpfrResult;
     bool erangeflag = mpfr::RoundToLong(x, mpfrResult);
     ASSERT_FALSE(erangeflag);
     testOneInput(func, x, mpfrResult, false);
   }
 
   void testRoundNumbers(RoundToIntegerFunc func) {
     if (TestModes) {
       for (int mode : roundingModes) {
-        __llvm_libc::fputil::setRound(mode);
+        __llvm_libc::fputil::set_round(mode);
         doRoundNumbersTest(func);
       }
     } else {
       doRoundNumbersTest(func);
     }
   }
 
   void doFractionsTest(RoundToIntegerFunc func, int mode) {
for (F x : fractions) {
       I mpfrResult = mpfrLongResult;
       testOneInput(func, x, mpfrResult, false);
     }
   }
 
   void testFractions(RoundToIntegerFunc func) {
     if (TestModes) {
       for (int mode : roundingModes) {
-        __llvm_libc::fputil::setRound(mode);
+        __llvm_libc::fputil::set_round(mode);
         doFractionsTest(func, mode);
       }
     } else {
       // Passing 0 for mode has no effect as it is not used in doFractionsTest
       // when `TestModes` is false;
       doFractionsTest(func, 0);
     }
   }
 
   void testIntegerOverflow(RoundToIntegerFunc func) {
     // This function compares with an equivalent MPFR function which rounds
     // floating point numbers to long values. There is no MPFR function to
     // round to long long or wider integer values. So, we will peform the
     // comparisons in this function only if the width of I less than equal to
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr int exponentLimit = sizeof(I) * 8 - 1;
     // We start with 1.0 so that the implicit bit for x86 long doubles
     // is set.
     FPBits bits(F(1.0));
-    bits.setUnbiasedExponent(exponentLimit + FPBits::exponentBias);
-    bits.setSign(1);
-    bits.setMantissa(UIntType(0x1) << (__llvm_libc::fputil::MantissaWidth<F>::value - 1));
+    bits.set_unbiased_exponent(exponentLimit + FPBits::EXPONENT_BIAS);
+    bits.set_sign(1);
+    bits.set_mantissa(UIntType(0x1)
+                      << (__llvm_libc::fputil::MantissaWidth<F>::VALUE - 1));
 
     F x = F(bits);
     if (TestModes) {
       for (int m : roundingModes) {
-        __llvm_libc::fputil::setRound(m);
+        __llvm_libc::fputil::set_round(m);
         long mpfrLongResult;
         bool erangeflag =
             mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
         ASSERT_TRUE(erangeflag);
         testOneInput(func, x, IntegerMin, true);
       }
     } else {
       long mpfrLongResult;
       bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);
       ASSERT_TRUE(erangeflag);
       testOneInput(func, x, IntegerMin, true);
     }
   }
 
   void testSubnormalRange(RoundToIntegerFunc func) {
     constexpr UIntType count = 1000001;
     constexpr UIntType step =
-        (FPBits::maxSubnormal - FPBits::minSubnormal) / count;
-    for (UIntType i = FPBits::minSubnormal; i <= FPBits::maxSubnormal;
+        (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / count;
+    for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
          i += step) {
       F x = F(FPBits(i));
       if (x == F(0.0))
         continue;
       // All subnormal numbers should round to zero.
       if (TestModes) {
         if (x > 0) {
-          __llvm_libc::fputil::setRound(FE_UPWARD);
+          __llvm_libc::fputil::set_round(FE_UPWARD);
           testOneInput(func, x, I(1), false);
-          __llvm_libc::fputil::setRound(FE_DOWNWARD);
+          __llvm_libc::fputil::set_round(FE_DOWNWARD);
           testOneInput(func, x, I(0), false);
-          __llvm_libc::fputil::setRound(FE_TOWARDZERO);
+          __llvm_libc::fputil::set_round(FE_TOWARDZERO);
           testOneInput(func, x, I(0), false);
-          __llvm_libc::fputil::setRound(FE_TONEAREST);
+          __llvm_libc::fputil::set_round(FE_TONEAREST);
           testOneInput(func, x, I(0), false);
         } else {
-          __llvm_libc::fputil::setRound(FE_UPWARD);
+          __llvm_libc::fputil::set_round(FE_UPWARD);
           testOneInput(func, x, I(0), false);
-          __llvm_libc::fputil::setRound(FE_DOWNWARD);
+          __llvm_libc::fputil::set_round(FE_DOWNWARD);
           testOneInput(func, x, I(-1), false);
-          __llvm_libc::fputil::setRound(FE_TOWARDZERO);
+          __llvm_libc::fputil::set_round(FE_TOWARDZERO);
           testOneInput(func, x, I(0), false);
-          __llvm_libc::fputil::setRound(FE_TONEAREST);
+          __llvm_libc::fputil::set_round(FE_TONEAREST);
           testOneInput(func, x, I(0), false);
         }
       } else {
         testOneInput(func, x, 0L, false);
       }
     }
   }
 
   void testNormalRange(RoundToIntegerFunc func) {
     // This function compares with an equivalent MPFR function which rounds
     // floating point numbers to long values. There is no MPFR function to
     // round to long long or wider integer values. So, we will peform the
     // comparisons in this function only if the width of I less than equal to
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
     constexpr UIntType count = 1000001;
-    constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
-    for (UIntType i = FPBits::minNormal; i <= FPBits::maxNormal; i += step) {
+    constexpr UIntType step = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / count;
+    for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += step) {
       F x = F(FPBits(i));
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. We will skip them.
       if (isnan(x)) {
         continue;
       }
 
       if (TestModes) {
         for (int m : roundingModes) {
           long mpfrLongResult;
           bool erangeflag =
               mpfr::RoundToLong(x, toMPFRRoundingMode(m), mpfrLongResult);
           I mpfrResult = mpfrLongResult;
-          __llvm_libc::fputil::setRound(m);
+          __llvm_libc::fputil::set_round(m);
           if (erangeflag)
             testOneInput(func, x, x > 0 ? IntegerMax : IntegerMin, true);
           else
             testOneInput(func, x, mpfrResult, false);
         }
       } else {
         long mpfrLongResult;
         bool erangeflag = mpfr::RoundToLong(x, mpfrLongResult);

libc/test/src/math/SqrtTest.h

 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
   static constexpr UIntType HiddenBit =
-      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::value;
+      UIntType(1) << __llvm_libc::fputil::MantissaWidth<T>::VALUE;
 
 public:
   typedef T (*SqrtFunc)(T);
 
   void testSpecialNumbers(SqrtFunc func) {
     ASSERT_FP_EQ(aNaN, func(aNaN));
     ASSERT_FP_EQ(inf, func(inf));
-    ASSERT_FP_EQ(aNaN, func(negInf));
+    ASSERT_FP_EQ(aNaN, func(neg_inf));
     ASSERT_FP_EQ(0.0, func(0.0));
     ASSERT_FP_EQ(-0.0, func(-0.0));
     ASSERT_FP_EQ(aNaN, func(T(-1.0)));
     ASSERT_FP_EQ(T(1.0), func(T(1.0)));
     ASSERT_FP_EQ(T(2.0), func(T(4.0)));
     ASSERT_FP_EQ(T(3.0), func(T(9.0)));
   }
 
   void testDenormalValues(SqrtFunc func) {
     for (UIntType mant = 1; mant < HiddenBit; mant <<= 1) {
       FPBits denormal(T(0.0));
-      denormal.setMantissa(mant);
+      denormal.set_mantissa(mant);
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, T(denormal), func(T(denormal)),
                         T(0.5));
     }
 
     constexpr UIntType count = 1'000'001;
     constexpr UIntType step = HiddenBit / count;
     for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {

libc/test/src/math/TruncTest.h

template <typename T> class TruncTest : public __llvm_libc::testing::Test {
 
   DECLARE_SPECIAL_CONSTANTS(T)
 
 public:
   typedef T (*TruncFunc)(T);
 
   void testSpecialNumbers(TruncFunc func) {
     EXPECT_FP_EQ(zero, func(zero));
-    EXPECT_FP_EQ(negZero, func(negZero));
+    EXPECT_FP_EQ(neg_zero, func(neg_zero));
 
     EXPECT_FP_EQ(inf, func(inf));
-    EXPECT_FP_EQ(negInf, func(negInf));
+    EXPECT_FP_EQ(neg_inf, func(neg_inf));
 
     EXPECT_FP_EQ(aNaN, func(aNaN));
   }
 
   void testRoundedNumbers(TruncFunc func) {
     EXPECT_FP_EQ(T(1.0), func(T(1.0)));
     EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
     EXPECT_FP_EQ(T(10.0), func(T(10.0)));

libc/test/src/math/cosf_test.cpp

TEST(LlvmLibcCosfTest, SpecialNumbers) {
   EXPECT_FP_EQ(1.0f, __llvm_libc::cosf(-0.0f));
   EXPECT_EQ(errno, 0);
 
   errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(inf));
   EXPECT_EQ(errno, EDOM);
 
   errno = 0;
-  EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(negInf));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf));
   EXPECT_EQ(errno, EDOM);
 }
 
 TEST(LlvmLibcCosfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;
   for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
     float x = float(FPBits(v));

libc/test/src/math/exhaustive/expm1f_test.cpp

 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(LlvmLibcExpm1fExhaustiveTest, AllValues) {
   uint32_t bits = 0;
   do {
     FPBits x(bits);
-    if (!x.isInfOrNaN() && float(x) < 88.70f) {
+    if (!x.is_inf_or_nan() && float(x) < 88.70f) {
       ASSERT_MPFR_MATCH(mpfr::Operation::Expm1, float(x),
                         __llvm_libc::expm1f(float(x)), 1.5);
     }
   } while (bits++ < 0xffff'ffffU);
 }

libc/test/src/math/exp2f_test.cpp

TEST(LlvmLibcExp2fTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(inf));
   EXPECT_EQ(errno, 0);
 
-  EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(negInf));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(neg_inf));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(0.0f));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
   EXPECT_EQ(errno, 0);
 }

libc/test/src/math/expf_test.cpp

TEST(LlvmLibcExpfTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::expf(aNaN));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::expf(inf));
   EXPECT_EQ(errno, 0);
 
-  EXPECT_FP_EQ(0.0f, __llvm_libc::expf(negInf));
+  EXPECT_FP_EQ(0.0f, __llvm_libc::expf(neg_inf));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::expf(0.0f));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::expf(-0.0f));
   EXPECT_EQ(errno, 0);
 }

libc/test/src/math/expm1f_test.cpp

TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
   errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::expm1f(aNaN));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::expm1f(inf));
   EXPECT_EQ(errno, 0);
 
-  EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(negInf));
+  EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(neg_inf));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::expm1f(0.0f));
   EXPECT_EQ(errno, 0);
 
   EXPECT_FP_EQ(-0.0f, __llvm_libc::expm1f(-0.0f));
   EXPECT_EQ(errno, 0);
 }

libc/test/src/math/sincosf_test.cpp

TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
 
   errno = 0;
   __llvm_libc::sincosf(inf, &sin, &cos);
   EXPECT_FP_EQ(aNaN, cos);
   EXPECT_FP_EQ(aNaN, sin);
   EXPECT_EQ(errno, EDOM);
 
   errno = 0;
-  __llvm_libc::sincosf(negInf, &sin, &cos);
+  __llvm_libc::sincosf(neg_inf, &sin, &cos);
   EXPECT_FP_EQ(aNaN, cos);
   EXPECT_FP_EQ(aNaN, sin);
   EXPECT_EQ(errno, EDOM);
 }
 
 TEST(LlvmLibcSinCosfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;

libc/test/src/math/sinf_test.cpp

TEST(LlvmLibcSinfTest, SpecialNumbers) {
   EXPECT_FP_EQ(-0.0f, __llvm_libc::sinf(-0.0f));
   EXPECT_EQ(errno, 0);
 
   errno = 0;
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(inf));
   EXPECT_EQ(errno, EDOM);
 
   errno = 0;
-  EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(negInf));
+  EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf));
   EXPECT_EQ(errno, EDOM);
 }
 
 TEST(LlvmLibcSinfTest, InFloatRange) {
   constexpr uint32_t count = 1000000;
   constexpr uint32_t step = UINT32_MAX / count;
   for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) {
     float x = float(FPBits(v));

libc/test/src/stdlib/atof_test.cpp

TEST(LlvmLibcAToFTest, SimpleTest) {
 
   errno = 0;
   double result = __llvm_libc::atof("123");
 
   __llvm_libc::fputil::FPBits<double> actualFP =
       __llvm_libc::fputil::FPBits<double>(result);
 
   EXPECT_EQ(actualFP.bits, expectedFP.bits);
-  EXPECT_EQ(actualFP.getSign(), expectedFP.getSign());
-  EXPECT_EQ(actualFP.getExponent(), expectedFP.getExponent());
-  EXPECT_EQ(actualFP.getMantissa(), expectedFP.getMantissa());
+  EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
+  EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
+  EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
   EXPECT_EQ(errno, 0);
 }
 
 TEST(LlvmLibcAToFTest, FailedParsingTest) {
   __llvm_libc::fputil::FPBits<double> expectedFP =
       __llvm_libc::fputil::FPBits<double>(uint64_t(0));
 
   errno = 0;
   double result = __llvm_libc::atof("???");
 
   __llvm_libc::fputil::FPBits<double> actualFP =
       __llvm_libc::fputil::FPBits<double>(result);
 
   EXPECT_EQ(actualFP.bits, expectedFP.bits);
-  EXPECT_EQ(actualFP.getSign(), expectedFP.getSign());
-  EXPECT_EQ(actualFP.getExponent(), expectedFP.getExponent());
-  EXPECT_EQ(actualFP.getMantissa(), expectedFP.getMantissa());
+  EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
+  EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
+  EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
   EXPECT_EQ(errno, 0);
 }

libc/test/src/stdlib/strtod_test.cpp

void runTest(const char *inputString, const ptrdiff_t expectedStrLen,
     double result = __llvm_libc::strtod(inputString, &strEnd);
 
     __llvm_libc::fputil::FPBits<double> actualFP =
         __llvm_libc::fputil::FPBits<double>(result);
 
     EXPECT_EQ(strEnd - inputString, expectedStrLen);
 
     EXPECT_EQ(actualFP.bits, expectedFP.bits);
-    EXPECT_EQ(actualFP.getSign(), expectedFP.getSign());
-    EXPECT_EQ(actualFP.getExponent(), expectedFP.getExponent());
-    EXPECT_EQ(actualFP.getMantissa(), expectedFP.getMantissa());
+    EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
+    EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
+    EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
     EXPECT_EQ(errno, expectedErrno);
   }
 };
 
 TEST_F(LlvmLibcStrToDTest, SimpleTest) {
   runTest("123", 3, uint64_t(0x405ec00000000000));
 
   // This should fail on Eisel-Lemire, forcing a fallback to simple decimal

libc/test/src/stdlib/strtof_test.cpp

void runTest(const char *inputString, const ptrdiff_t expectedStrLen,
     float result = __llvm_libc::strtof(inputString, &strEnd);
 
     __llvm_libc::fputil::FPBits<float> actualFP =
         __llvm_libc::fputil::FPBits<float>(result);
 
     EXPECT_EQ(strEnd - inputString, expectedStrLen);
 
     EXPECT_EQ(actualFP.bits, expectedFP.bits);
-    EXPECT_EQ(actualFP.getSign(), expectedFP.getSign());
-    EXPECT_EQ(actualFP.getExponent(), expectedFP.getExponent());
-    EXPECT_EQ(actualFP.getMantissa(), expectedFP.getMantissa());
+    EXPECT_EQ(actualFP.get_sign(), expectedFP.get_sign());
+    EXPECT_EQ(actualFP.get_exponent(), expectedFP.get_exponent());
+    EXPECT_EQ(actualFP.get_mantissa(), expectedFP.get_mantissa());
     EXPECT_EQ(errno, expectedErrno);
   }
 };
 
 // This is the set of tests that I have working (verified correct when compared
 // to system libc). This is here so I don't break more things when I try to fix
 // them.
 

libc/test/src/string/memory_utils/elements_test.cpp

char GetRandomChar() {
   return seed;
 }
 
 void Randomize(cpp::MutableArrayRef<char> buffer) {
   for (auto &current : buffer)
     current = GetRandomChar();
 }
 
-template <typename Element> using Buffer = cpp::Array<char, Element::kSize>;
+template <typename Element> using Buffer = cpp::Array<char, Element::SIZE>;
 
 template <typename Element> Buffer<Element> GetRandomBuffer() {
   Buffer<Element> buffer;
   Randomize(buffer);
   return buffer;
 }
 
-TYPED_TEST(LlvmLibcMemoryElements, Copy, FixedSizeTypes) {
+TYPED_TEST(LlvmLibcMemoryElements, copy, FixedSizeTypes) {
   Buffer<ParamType> Dst;
   const auto buffer = GetRandomBuffer<ParamType>();
-  Copy<ParamType>(Dst.data(), buffer.data());
-  for (size_t i = 0; i < ParamType::kSize; ++i)
+  copy<ParamType>(Dst.data(), buffer.data());
+  for (size_t i = 0; i < ParamType::SIZE; ++i)
     EXPECT_EQ(Dst[i], buffer[i]);
 }
 
-template <typename T> T Copy(const T &Input) {
+template <typename T> T copy(const T &Input) {
   T Output;
   for (size_t I = 0; I < Input.size(); ++I)
     Output[I] = Input[I];
   return Output;
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, Move, FixedSizeTypes) {
-  constexpr size_t kSize = ParamType::kSize;
-  using LargeBuffer = cpp::Array<char, kSize * 2>;
+  constexpr size_t SIZE = ParamType::SIZE;
+  using LargeBuffer = cpp::Array<char, SIZE * 2>;
   LargeBuffer GroundTruth;
   Randomize(GroundTruth);
-  // Forward, we move the kSize first bytes from offset 0 to kSize.
-  for (size_t Offset = 0; Offset < kSize; ++Offset) {
-    LargeBuffer Buffer = Copy(GroundTruth);
-    Move<ParamType>(&Buffer[Offset], &Buffer[0]);
-    for (size_t I = 0; I < kSize; ++I)
+  // Forward, we move the SIZE first bytes from offset 0 to SIZE.
+  for (size_t Offset = 0; Offset < SIZE; ++Offset) {
+    LargeBuffer Buffer = copy(GroundTruth);
+    move<ParamType>(&Buffer[Offset], &Buffer[0]);
+    for (size_t I = 0; I < SIZE; ++I)
       EXPECT_EQ(Buffer[I + Offset], GroundTruth[I]);
   }
-  // Backward, we move the kSize last bytes from offset 0 to kSize.
-  for (size_t Offset = 0; Offset < kSize; ++Offset) {
-    LargeBuffer Buffer = Copy(GroundTruth);
-    Move<ParamType>(&Buffer[Offset], &Buffer[kSize]);
-    for (size_t I = 0; I < kSize; ++I)
-      EXPECT_EQ(Buffer[I + Offset], GroundTruth[kSize + I]);
+  // Backward, we move the SIZE last bytes from offset 0 to SIZE.
+  for (size_t Offset = 0; Offset < SIZE; ++Offset) {
+    LargeBuffer Buffer = copy(GroundTruth);
+    move<ParamType>(&Buffer[Offset], &Buffer[SIZE]);
+    for (size_t I = 0; I < SIZE; ++I)
+      EXPECT_EQ(Buffer[I + Offset], GroundTruth[SIZE + I]);
   }
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, Equals, FixedSizeTypes) {
   const auto buffer = GetRandomBuffer<ParamType>();
-  EXPECT_TRUE(Equals<ParamType>(buffer.data(), buffer.data()));
+  EXPECT_TRUE(equals<ParamType>(buffer.data(), buffer.data()));
 }
 
-TYPED_TEST(LlvmLibcMemoryElements, ThreeWayCompare, FixedSizeTypes) {
+TYPED_TEST(LlvmLibcMemoryElements, three_way_compare, FixedSizeTypes) {
   Buffer<ParamType> initial;
   for (auto &c : initial)
     c = 5;
 
   // Testing equality
-  EXPECT_EQ(ThreeWayCompare<ParamType>(initial.data(), initial.data()), 0);
+  EXPECT_EQ(three_way_compare<ParamType>(initial.data(), initial.data()), 0);
 
   // Testing all mismatching positions
-  for (size_t i = 0; i < ParamType::kSize; ++i) {
+  for (size_t i = 0; i < ParamType::SIZE; ++i) {
     auto copy = initial;
-    ++copy[i]; // Copy is now lexicographycally greated than initial
+    ++copy[i]; // copy is now lexicographycally greated than initial
     const auto *less = initial.data();
     const auto *greater = copy.data();
-    EXPECT_LT(ThreeWayCompare<ParamType>(less, greater), 0);
-    EXPECT_GT(ThreeWayCompare<ParamType>(greater, less), 0);
+    EXPECT_LT(three_way_compare<ParamType>(less, greater), 0);
+    EXPECT_GT(three_way_compare<ParamType>(greater, less), 0);
   }
 }
 
 TYPED_TEST(LlvmLibcMemoryElements, Splat, FixedSizeTypes) {
   Buffer<ParamType> Dst;
   const cpp::Array<char, 3> values = {char(0x00), char(0x7F), char(0xFF)};
   for (char value : values) {
-    SplatSet<ParamType>(Dst.data(), value);
-    for (size_t i = 0; i < ParamType::kSize; ++i)
+    splat_set<ParamType>(Dst.data(), value);
+    for (size_t i = 0; i < ParamType::SIZE; ++i)
       EXPECT_EQ(Dst[i], value);
   }
 }
 
 } // namespace __llvm_libc

libc/test/src/string/memory_utils/memory_access_test.cpp

struct MemoryAccessObserver {
 
   Buffer Buffer1;
   Buffer Buffer2;
 };
 
 MemoryAccessObserver Observer;
 
 template <size_t Size> struct TestingElement {
-  static constexpr size_t kSize = Size;
+  static constexpr size_t SIZE = Size;
 
-  static void Copy(char *__restrict dst, const char *__restrict src) {
-    Observer.ObserveRead(src, kSize);
-    Observer.ObserveWrite(dst, kSize);
+  static void copy(char *__restrict dst, const char *__restrict src) {
+    Observer.ObserveRead(src, SIZE);
+    Observer.ObserveWrite(dst, SIZE);
   }
 
-  static bool Equals(const char *lhs, const char *rhs) {
-    Observer.ObserveRead(lhs, kSize);
-    Observer.ObserveRead(rhs, kSize);
+  static bool equals(const char *lhs, const char *rhs) {
+    Observer.ObserveRead(lhs, SIZE);
+    Observer.ObserveRead(rhs, SIZE);
     return true;
   }
 
-  static int ThreeWayCompare(const char *lhs, const char *rhs) {
-    Observer.ObserveRead(lhs, kSize);
-    Observer.ObserveRead(rhs, kSize);
+  static int three_way_compare(const char *lhs, const char *rhs) {
+    Observer.ObserveRead(lhs, SIZE);
+    Observer.ObserveRead(rhs, SIZE);
     return 0;
   }
 
-  static void SplatSet(char *dst, const unsigned char value) {
-    Observer.ObserveWrite(dst, kSize);
+  static void splat_set(char *dst, const unsigned char value) {
+    Observer.ObserveWrite(dst, SIZE);
   }
 };
 
 using Types = testing::TypeList<
     TestingElement<1>,                                               // 1 Byte
     TestingElement<2>,                                               // 2 Bytes
     TestingElement<4>,                                               // 4 Bytes
     Repeated<TestingElement<2>, 3>,                                  // 6 Bytes
     Chained<TestingElement<4>, TestingElement<2>, TestingElement<1>> // 7 Bytes
     >;
 
 struct LlvmLibcTestAccessBase : public testing::Test {
 
   template <typename HigherOrder, size_t Size, size_t Offset = 0>
   void checkOperations(const BufferAccess &expected) {
     static const BufferAccess untouched;
 
     Observer.Reset();
-    HigherOrder::Copy(dst_ptr() + Offset, src_ptr() + Offset, Size);
+    HigherOrder::copy(dst_ptr() + Offset, src_ptr() + Offset, Size);
     ASSERT_STREQ(src().writes, untouched);
     ASSERT_STREQ(dst().reads, untouched);
     ASSERT_STREQ(src().reads, expected);
     ASSERT_STREQ(dst().writes, expected);
     Observer.Reset();
-    HigherOrder::Equals(lhs_ptr() + Offset, rhs_ptr() + Offset, Size);
+    HigherOrder::equals(lhs_ptr() + Offset, rhs_ptr() + Offset, Size);
     ASSERT_STREQ(lhs().writes, untouched);
     ASSERT_STREQ(rhs().writes, untouched);
     ASSERT_STREQ(lhs().reads, expected);
     ASSERT_STREQ(rhs().reads, expected);
     Observer.Reset();
-    HigherOrder::ThreeWayCompare(lhs_ptr() + Offset, rhs_ptr() + Offset, Size);
+    HigherOrder::three_way_compare(lhs_ptr() + Offset, rhs_ptr() + Offset,
+                                   Size);
     ASSERT_STREQ(lhs().writes, untouched);
     ASSERT_STREQ(rhs().writes, untouched);
     ASSERT_STREQ(lhs().reads, expected);
     ASSERT_STREQ(rhs().reads, expected);
     Observer.Reset();
-    HigherOrder::SplatSet(dst_ptr() + Offset, 5, Size);
+    HigherOrder::splat_set(dst_ptr() + Offset, 5, Size);
     ASSERT_STREQ(src().reads, untouched);
     ASSERT_STREQ(src().writes, untouched);
     ASSERT_STREQ(dst().reads, untouched);
     ASSERT_STREQ(dst().writes, expected);
   }
 
   void checkMaxAccess(const BufferAccess &expected, int max) {
     for (size_t i = 0; i < kMaxBuffer; ++i) {

 
 template <typename ParamType>
 struct LlvmLibcTestAccessTail : public LlvmLibcTestAccessBase {
 
   void TearDown() override {
     static constexpr size_t Size = 10;
 
     BufferAccess expected;
-    expected.Touch(Size - ParamType::kSize, ParamType::kSize);
+    expected.Touch(Size - ParamType::SIZE, ParamType::SIZE);
 
     checkMaxAccess(expected, 1);
     checkOperations<Tail<ParamType>, Size>(expected);
   }
 };
 TYPED_TEST_F(LlvmLibcTestAccessTail, Operations, Types) {}
 
 template <typename ParamType>
 struct LlvmLibcTestAccessHeadTail : public LlvmLibcTestAccessBase {
   void TearDown() override {
     static constexpr size_t Size = 10;
 
     BufferAccess expected;
-    expected.Touch(0, ParamType::kSize);
-    expected.Touch(Size - ParamType::kSize, ParamType::kSize);
+    expected.Touch(0, ParamType::SIZE);
+    expected.Touch(Size - ParamType::SIZE, ParamType::SIZE);
 
     checkMaxAccess(expected, 2);
     checkOperations<HeadTail<ParamType>, Size>(expected);
   }
 };
 TYPED_TEST_F(LlvmLibcTestAccessHeadTail, Operations, Types) {}
 
 template <typename ParamType>
 struct LlvmLibcTestAccessLoop : public LlvmLibcTestAccessBase {
   void TearDown() override {
     static constexpr size_t Size = 20;
 
     BufferAccess expected;
-    for (size_t i = 0; i < Size - ParamType::kSize; i += ParamType::kSize)
-      expected.Touch(i, ParamType::kSize);
-    expected.Touch(Size - ParamType::kSize, ParamType::kSize);
+    for (size_t i = 0; i < Size - ParamType::SIZE; i += ParamType::SIZE)
+      expected.Touch(i, ParamType::SIZE);
+    expected.Touch(Size - ParamType::SIZE, ParamType::SIZE);
 
     checkMaxAccess(expected, 2);
     checkOperations<Loop<ParamType>, Size>(expected);
   }
 };
 TYPED_TEST_F(LlvmLibcTestAccessLoop, Operations, Types) {}
 
 template <typename ParamType>
 struct LlvmLibcTestAccessAlignedAccess : public LlvmLibcTestAccessBase {
   void TearDown() override {
     static constexpr size_t Size = 10;
     static constexpr size_t Offset = 2;
     using AlignmentT = TestingElement<4>;
 
     BufferAccess expected;
-    expected.Touch(Offset, AlignmentT::kSize);
-    expected.Touch(AlignmentT::kSize, ParamType::kSize);
-    expected.Touch(Offset + Size - ParamType::kSize, ParamType::kSize);
+    expected.Touch(Offset, AlignmentT::SIZE);
+    expected.Touch(AlignmentT::SIZE, ParamType::SIZE);
+    expected.Touch(Offset + Size - ParamType::SIZE, ParamType::SIZE);
 
     checkMaxAccess(expected, 3);
     checkOperations<Align<AlignmentT, Arg::_1>::Then<HeadTail<ParamType>>, Size,
                     Offset>(expected);
     checkOperations<Align<AlignmentT, Arg::_2>::Then<HeadTail<ParamType>>, Size,
                     Offset>(expected);
   }
 };
 TYPED_TEST_F(LlvmLibcTestAccessAlignedAccess, Operations, Types) {}
 
 } // namespace __llvm_libc

libc/test/src/time/TmHelper.h

static inline void InitializeTmData(struct tm *tm_data, int year, int month,
                                     int mday, int hour, int min, int sec,
                                     int wday, int yday) {
   struct tm temp = {.tm_sec = sec,
                     .tm_min = min,
                     .tm_hour = hour,
                     .tm_mday = mday,
                     .tm_mon = month - 1, // tm_mon starts with 0 for Jan
                     // years since 1900
-                    .tm_year = year - TimeConstants::TimeYearBase,
+                    .tm_year = year - TimeConstants::TIME_YEAR_BASE,
                     .tm_wday = wday,
                     .tm_yday = yday};
   *tm_data = temp;
 }
 
 } // namespace testing
 } // namespace tmhelper
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_TEST_SRC_TIME_TM_HELPER_H

libc/test/src/time/asctime_r_test.cpp

 // asctime and asctime_r share the same code and thus didn't repeat all the
 // tests from asctime. Added couple of validation tests.
 TEST(LlvmLibcAsctimeR, Nullptr) {
   char *result;
   result = __llvm_libc::asctime_r(nullptr, nullptr);
   ASSERT_EQ(EINVAL, llvmlibc_errno);
   ASSERT_STREQ(nullptr, result);
 
-  char buffer[TimeConstants::AsctimeBufferSize];
+  char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
   result = __llvm_libc::asctime_r(nullptr, buffer);
   ASSERT_EQ(EINVAL, llvmlibc_errno);
   ASSERT_STREQ(nullptr, result);
 
   struct tm tm_data;
   result = __llvm_libc::asctime_r(&tm_data, nullptr);
   ASSERT_EQ(EINVAL, llvmlibc_errno);
   ASSERT_STREQ(nullptr, result);
 }
 
 TEST(LlvmLibcAsctimeR, ValidDate) {
-  char buffer[TimeConstants::AsctimeBufferSize];
+  char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00. Test with a valid buffer size.
   result = call_asctime_r(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           4,    // wday
                           0,    // yday
                           buffer);
   ASSERT_STREQ("Thu Jan  1 00:00:00 1970\n", result);
 }

libc/test/src/time/gmtime_r_test.cpp

TEST(LlvmLibcGmTimeR, EndOf32BitEpochYear) {
   struct tm tm_data;
   struct tm *tm_data_ptr;
   tm_data_ptr = __llvm_libc::gmtime_r(&seconds, &tm_data);
   EXPECT_TM_EQ((tm{7,  // sec
                    14, // min
                    3,  // hr
                    19, // day
                    0,  // tm_mon starts with 0 for Jan
-                   2038 - TimeConstants::TimeYearBase, // year
-                   2,                                  // wday
-                   7,                                  // yday
+                   2038 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                    // wday
+                   7,                                    // yday
                    0}),
                *tm_data_ptr);
   EXPECT_TM_EQ(*tm_data_ptr, tm_data);
 }
 
 TEST(LlvmLibcGmTimeR, Max64BitYear) {
   if (sizeof(time_t) == 4)
     return;
   // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
   time_t seconds = 67767976202043050;
   struct tm tm_data;
   struct tm *tm_data_ptr;
   tm_data_ptr = __llvm_libc::gmtime_r(&seconds, &tm_data);
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
-                   2147483647 - TimeConstants::TimeYearBase, // year
-                   2,                                        // wday
-                   50,                                       // yday
+                   2147483647 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                          // wday
+                   50,                                         // yday
                    0}),
                *tm_data_ptr);
   EXPECT_TM_EQ(*tm_data_ptr, tm_data);
 }

libc/test/src/time/gmtime_test.cpp

 #include <limits.h>
 #include <string.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;
 
 TEST(LlvmLibcGmTime, OutOfRange) {
-  time_t seconds = 1 + INT_MAX * static_cast<int64_t>(
-                                     TimeConstants::NumberOfSecondsInLeapYear);
+  time_t seconds =
+      1 + INT_MAX * static_cast<int64_t>(
+                        TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR);
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
   EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
 
   llvmlibc_errno = 0;
-  seconds =
-      INT_MIN * static_cast<int64_t>(TimeConstants::NumberOfSecondsInLeapYear) -
+  seconds = INT_MIN * static_cast<int64_t>(
+                          TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR) -
             1;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
   EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
 }
 
 TEST(LlvmLibcGmTime, InvalidSeconds) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
   seconds = -1;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{59,     // sec
                    59,     // min
                    23,     // hr
                    31,     // day
                    12 - 1, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   364,                                // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   364,                                  // yday
                    0}),
                *tm_data);
   // 60 seconds from 1970-01-01 00:00:00 returns 1970-01-01 00:01:00.
   seconds = 60;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    1, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   4,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   4,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, InvalidMinutes) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
-  seconds = -TimeConstants::SecondsPerMin;
+  seconds = -TimeConstants::SECONDS_PER_MIN;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0,  // sec
                    59, // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
   // 60 minutes from 1970-01-01 00:00:00 returns 1970-01-01 01:00:00.
-  seconds = 60 * TimeConstants::SecondsPerMin;
+  seconds = 60 * TimeConstants::SECONDS_PER_MIN;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    1, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   4,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   4,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, InvalidHours) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
-  seconds = -TimeConstants::SecondsPerHour;
+  seconds = -TimeConstants::SECONDS_PER_HOUR;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
   // 24 hours from 1970-01-01 00:00:00 returns 1970-01-02 00:00:00.
-  seconds = 24 * TimeConstants::SecondsPerHour;
+  seconds = 24 * TimeConstants::SECONDS_PER_HOUR;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    2, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   5,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   5,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, InvalidYear) {
   // -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
   time_t seconds =
-      -TimeConstants::DaysPerNonLeapYear * TimeConstants::SecondsPerDay;
+      -TimeConstants::DAYS_PER_NON_LEAP_YEAR * TimeConstants::SECONDS_PER_DAY;
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, InvalidMonths) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
-  seconds = -31 * TimeConstants::SecondsPerDay;
+  seconds = -31 * TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0,      // sec
                    0,      // min
                    0,      // hr
                    1,      // day
                    12 - 1, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   1,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   1,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
   // 1970-13-01 00:00:00 returns 1971-01-01 00:00:00.
-  seconds = TimeConstants::DaysPerNonLeapYear * TimeConstants::SecondsPerDay;
+  seconds =
+      TimeConstants::DAYS_PER_NON_LEAP_YEAR * TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1971 - TimeConstants::TimeYearBase, // year
-                   5,                                  // wday
-                   0,                                  // yday
+                   1971 - TimeConstants::TIME_YEAR_BASE, // year
+                   5,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, InvalidDays) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
-  seconds = -1 * TimeConstants::SecondsPerDay;
+  seconds = -1 * TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    0,  // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 
   // 1970-01-32 00:00:00 returns 1970-02-01 00:00:00.
-  seconds = 31 * TimeConstants::SecondsPerDay;
+  seconds = 31 * TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   0,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   0,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 
   // 1970-02-29 00:00:00 returns 1970-03-01 00:00:00.
-  seconds = 59 * TimeConstants::SecondsPerDay;
+  seconds = 59 * TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   0,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   0,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 
   // 1972-02-30 00:00:00 returns 1972-03-01 00:00:00.
-  seconds = ((2 * TimeConstants::DaysPerNonLeapYear) + 60) *
-            TimeConstants::SecondsPerDay;
+  seconds = ((2 * TimeConstants::DAYS_PER_NON_LEAP_YEAR) + 60) *
+            TimeConstants::SECONDS_PER_DAY;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
-                   1972 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1972 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, EndOf32BitEpochYear) {
   // Test for maximum value of a signed 32-bit integer.
   // Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
   time_t seconds = 0x7FFFFFFF;
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{7,  // sec
                    14, // min
                    3,  // hr
                    19, // day
                    0,  // tm_mon starts with 0 for Jan
-                   2038 - TimeConstants::TimeYearBase, // year
-                   2,                                  // wday
-                   7,                                  // yday
+                   2038 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                    // wday
+                   7,                                    // yday
                    0}),
                *tm_data);
 }
 
 TEST(LlvmLibcGmTime, Max64BitYear) {
   if (sizeof(time_t) == 4)
     return;
   // Mon Jan 1 12:50:50 2170 (200 years from 1970),
   time_t seconds = 6311479850;
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
-                   2170 - TimeConstants::TimeYearBase, // year
-                   1,                                  // wday
-                   50,                                 // yday
+                   2170 - TimeConstants::TIME_YEAR_BASE, // year
+                   1,                                    // wday
+                   50,                                   // yday
                    0}),
                *tm_data);
 
   // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
   seconds = 67767976202043050;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
-                   2147483647 - TimeConstants::TimeYearBase, // year
-                   2,                                        // wday
-                   50,                                       // yday
+                   2147483647 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                          // wday
+                   50,                                         // yday
                    0}),
                *tm_data);
 }

libc/test/src/time/mktime_test.cpp

EXPECT_THAT(call_mktime(&tm_data,
                           0,    // wday
                           0),   // yday
               Succeeds(-1));
   EXPECT_TM_EQ((tm{59,     // sec
                    59,     // min
                    23,     // hr
                    31,     // day
                    12 - 1, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   364,                                // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   364,                                  // yday
                    0}),
                tm_data);
   // 60 seconds from 1970-01-01 00:00:00 returns 1970-01-01 00:01:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           60,   // sec
                           0,    // wday
                           0),   // yday
               Succeeds(60));
   EXPECT_TM_EQ((tm{0, // sec
                    1, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   4,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   4,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, InvalidMinutes) {
   struct tm tm_data;
   // -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           -1,   // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(-TimeConstants::SecondsPerMin));
+              Succeeds(-TimeConstants::SECONDS_PER_MIN));
   EXPECT_TM_EQ((tm{0,  // sec
                    59, // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
   // 60 minutes from 1970-01-01 00:00:00 returns 1970-01-01 01:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           60,   // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(60 * TimeConstants::SecondsPerMin));
+              Succeeds(60 * TimeConstants::SECONDS_PER_MIN));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    1, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   4,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   4,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, InvalidHours) {
   struct tm tm_data;
   // -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           -1,   // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(-TimeConstants::SecondsPerHour));
+              Succeeds(-TimeConstants::SECONDS_PER_HOUR));
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
   // 24 hours from 1970-01-01 00:00:00 returns 1970-01-02 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           24,   // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(24 * TimeConstants::SecondsPerHour));
+              Succeeds(24 * TimeConstants::SECONDS_PER_HOUR));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    2, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   5,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   5,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, InvalidYear) {
   struct tm tm_data;
   // -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1969, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(-TimeConstants::DaysPerNonLeapYear *
-                       TimeConstants::SecondsPerDay));
+              Succeeds(-TimeConstants::DAYS_PER_NON_LEAP_YEAR *
+                       TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, InvalidEndOf32BitEpochYear) {
   if (sizeof(size_t) != 4)
     return;
   struct tm tm_data;
   // 2038-01-19 03:14:08 tests overflow of the second in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 14, 8, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
   // 2038-01-19 03:15:07 tests overflow of the minute in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 15, 7, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
   // 2038-01-19 04:14:07 tests overflow of the hour in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 4, 14, 7, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
   // 2038-01-20 03:14:07 tests overflow of the day in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 20, 3, 14, 7, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
   // 2038-02-19 03:14:07 tests overflow of the month in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 2, 19, 3, 14, 7, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
   // 2039-01-19 03:14:07 tests overflow of the year.
   EXPECT_THAT(call_mktime(&tm_data, 2039, 1, 19, 3, 14, 7, 0, 0),
-              Succeeds(TimeConstants::OutOfRangeReturnValue));
+              Succeeds(TimeConstants::OUT_OF_RANGE_RETURN_VALUE));
 }
 
 TEST(LlvmLibcMkTime, InvalidMonths) {
   struct tm tm_data;
   // -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           0,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(-31 * TimeConstants::SecondsPerDay));
+              Succeeds(-31 * TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0,      // sec
                    0,      // min
                    0,      // hr
                    1,      // day
                    12 - 1, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   1,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   1,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
   // 1970-13-01 00:00:00 returns 1971-01-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           13,   // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(TimeConstants::DaysPerNonLeapYear *
-                       TimeConstants::SecondsPerDay));
+              Succeeds(TimeConstants::DAYS_PER_NON_LEAP_YEAR *
+                       TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1971 - TimeConstants::TimeYearBase, // year
-                   5,                                  // wday
-                   0,                                  // yday
+                   1971 - TimeConstants::TIME_YEAR_BASE, // year
+                   5,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, InvalidDays) {
   struct tm tm_data;
   // -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           0,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(-1 * TimeConstants::SecondsPerDay));
+              Succeeds(-1 * TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    0,  // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
-                   1969 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1969 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 
   // 1970-01-32 00:00:00 returns 1970-02-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           32,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(31 * TimeConstants::SecondsPerDay));
+              Succeeds(31 * TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   0,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   0,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 
   // 1970-02-29 00:00:00 returns 1970-03-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           2,    // month
                           29,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(59 * TimeConstants::SecondsPerDay));
+              Succeeds(59 * TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
-                   1970 - TimeConstants::TimeYearBase, // year
-                   0,                                  // wday
-                   0,                                  // yday
+                   1970 - TimeConstants::TIME_YEAR_BASE, // year
+                   0,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 
   // 1972-02-30 00:00:00 returns 1972-03-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1972, // year
                           2,    // month
                           30,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
-              Succeeds(((2 * TimeConstants::DaysPerNonLeapYear) + 60) *
-                       TimeConstants::SecondsPerDay));
+              Succeeds(((2 * TimeConstants::DAYS_PER_NON_LEAP_YEAR) + 60) *
+                       TimeConstants::SECONDS_PER_DAY));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
-                   1972 - TimeConstants::TimeYearBase, // year
-                   3,                                  // wday
-                   0,                                  // yday
+                   1972 - TimeConstants::TIME_YEAR_BASE, // year
+                   3,                                    // wday
+                   0,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, EndOf32BitEpochYear) {
   struct tm tm_data;
   // Test for maximum value of a signed 32-bit integer.
   // Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
   EXPECT_THAT(call_mktime(&tm_data,
                           2038, // year
                           1,    // month
                           19,   // day
                           3,    // hr
                           14,   // min
                           7,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(0x7FFFFFFF));
   EXPECT_TM_EQ((tm{7,  // sec
                    14, // min
                    3,  // hr
                    19, // day
                    0,  // tm_mon starts with 0 for Jan
-                   2038 - TimeConstants::TimeYearBase, // year
-                   2,                                  // wday
-                   7,                                  // yday
+                   2038 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                    // wday
+                   7,                                    // yday
                    0}),
                tm_data);
 }
 
 TEST(LlvmLibcMkTime, Max64BitYear) {
   if (sizeof(time_t) == 4)
     return;
   // Mon Jan 1 12:50:50 2170 (200 years from 1970),
   struct tm tm_data;
   EXPECT_THAT(call_mktime(&tm_data,
                           2170, // year
                           1,    // month
                           1,    // day
                           12,   // hr
                           50,   // min
                           50,   // sec
                           0,    // wday
                           0),   // yday
               Succeeds(6311479850));
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
-                   2170 - TimeConstants::TimeYearBase, // year
-                   1,                                  // wday
-                   50,                                 // yday
+                   2170 - TimeConstants::TIME_YEAR_BASE, // year
+                   1,                                    // wday
+                   50,                                   // yday
                    0}),
                tm_data);
 
   // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
   EXPECT_THAT(call_mktime(&tm_data, 2147483647, 1, 1, 12, 50, 50, 0, 0),
               Succeeds(67767976202043050));
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
-                   2147483647 - TimeConstants::TimeYearBase, // year
-                   2,                                        // wday
-                   50,                                       // yday
+                   2147483647 - TimeConstants::TIME_YEAR_BASE, // year
+                   2,                                          // wday
+                   50,                                         // yday
                    0}),
                tm_data);
 }

libc/test/utils/FPUtil/x86_long_double_test.cpp

 //===-- Unittests for x86 long double -------------------------------------===//
 //
 // 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 "src/__support/FPUtil/FPBits.h"
 #include "utils/UnitTest/Test.h"
 
 #include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
-TEST(X86LongDoubleTest, isNaN) {
+TEST(X86LongDoubleTest, is_nan) {
   // In the nan checks below, we use the macro isnan from math.h to ensure that
   // a number is actually a NaN. The isnan macro resolves to the compiler
   // builtin function. Hence, matching LLVM-libc's notion of NaN with the
   // isnan result ensures that LLVM-libc's behavior matches the compiler's
   // behavior.
 
   FPBits bits(0.0l);
-  bits.exponent = FPBits::maxExponent;
+  bits.exponent = FPBits::MAX_EXPONENT;
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent has the max value and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
     bits.mantissa = i;
     long double nan = bits;
     ASSERT_NE(isnan(nan), 0);
-    ASSERT_TRUE(bits.isNaN());
+    ASSERT_TRUE(bits.is_nan());
   }
 
   bits.implicitBit = 1;
   for (unsigned int i = 1; i < 1000000; ++i) {
     // If exponent has the max value and the implicit bit is 1,
     // then the number is a NaN for all non-zero values of mantissa.
     // Note the initial value of |i| of 1 to avoid a zero mantissa.
     bits.mantissa = i;
     long double nan = bits;
     ASSERT_NE(isnan(nan), 0);
-    ASSERT_TRUE(bits.isNaN());
+    ASSERT_TRUE(bits.is_nan());
   }
 
   bits.exponent = 1;
   bits.implicitBit = 0;
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
     bits.mantissa = i;
     long double nan = bits;
     ASSERT_NE(isnan(nan), 0);
-    ASSERT_TRUE(bits.isNaN());
+    ASSERT_TRUE(bits.is_nan());
   }
 
   bits.exponent = 1;
   bits.implicitBit = 1;
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 1,
     // then the number is normal value for all values of mantissa.
     bits.mantissa = i;
     long double valid = bits;
     ASSERT_EQ(isnan(valid), 0);
-    ASSERT_FALSE(bits.isNaN());
+    ASSERT_FALSE(bits.is_nan());
   }
 
   bits.exponent = 0;
   bits.implicitBit = 1;
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
     bits.mantissa = i;
     long double valid = bits;
     ASSERT_EQ(isnan(valid), 0);
-    ASSERT_FALSE(bits.isNaN());
+    ASSERT_FALSE(bits.is_nan());
   }
 
   bits.exponent = 0;
   bits.implicitBit = 0;
   for (unsigned int i = 0; i < 1000000; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
     bits.mantissa = i;
     long double valid = bits;
     ASSERT_EQ(isnan(valid), 0);
-    ASSERT_FALSE(bits.isNaN());
+    ASSERT_FALSE(bits.is_nan());
   }
 }

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   //    of N between this number and [input].
   // 4. A values of +0.0 and -0.0 are treated as equal.
   template <typename T>
   cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, double> ulp(T input) {
     T thisAsT = as<T>();
     if (thisAsT == input)
       return T(0.0);
 
-    int thisExponent = fputil::FPBits<T>(thisAsT).getExponent();
-    int inputExponent = fputil::FPBits<T>(input).getExponent();
+    int thisExponent = fputil::FPBits<T>(thisAsT).get_exponent();
+    int inputExponent = fputil::FPBits<T>(input).get_exponent();
     // Adjust the exponents for denormal numbers.
-    if (fputil::FPBits<T>(thisAsT).getUnbiasedExponent() == 0)
+    if (fputil::FPBits<T>(thisAsT).get_unbiased_exponent() == 0)
       ++thisExponent;
-    if (fputil::FPBits<T>(input).getUnbiasedExponent() == 0)
+    if (fputil::FPBits<T>(input).get_unbiased_exponent() == 0)
       ++inputExponent;
 
     if (thisAsT * input < 0 || thisExponent == inputExponent) {
       MPFRNumber inputMPFR(input);
       mpfr_sub(inputMPFR.value, value, inputMPFR.value, MPFR_RNDN);
       mpfr_abs(inputMPFR.value, inputMPFR.value, MPFR_RNDN);
       mpfr_mul_2si(inputMPFR.value, inputMPFR.value,
-                   -thisExponent + int(fputil::MantissaWidth<T>::value),
+                   -thisExponent + int(fputil::MantissaWidth<T>::VALUE),
                    MPFR_RNDN);
       return inputMPFR.as<double>();
     }
 
     // If the control reaches here, it means that this number and input are
     // of the same sign but different exponent. In such a case, ULP error is
     // calculated as sum of two parts.
     thisAsT = std::abs(thisAsT);
     input = std::abs(input);
     T min = thisAsT > input ? input : thisAsT;
     T max = thisAsT > input ? thisAsT : input;
-    int minExponent = fputil::FPBits<T>(min).getExponent();
-    int maxExponent = fputil::FPBits<T>(max).getExponent();
+    int minExponent = fputil::FPBits<T>(min).get_exponent();
+    int maxExponent = fputil::FPBits<T>(max).get_exponent();
     // Adjust the exponents for denormal numbers.
-    if (fputil::FPBits<T>(min).getUnbiasedExponent() == 0)
+    if (fputil::FPBits<T>(min).get_unbiased_exponent() == 0)
       ++minExponent;
-    if (fputil::FPBits<T>(max).getUnbiasedExponent() == 0)
+    if (fputil::FPBits<T>(max).get_unbiased_exponent() == 0)
       ++maxExponent;
 
     MPFRNumber minMPFR(min);
     MPFRNumber maxMPFR(max);
 
     MPFRNumber pivot(uint32_t(1));
     mpfr_mul_2si(pivot.value, pivot.value, maxExponent, MPFR_RNDN);
 
     mpfr_sub(minMPFR.value, pivot.value, minMPFR.value, MPFR_RNDN);
     mpfr_mul_2si(minMPFR.value, minMPFR.value,
-                 -minExponent + int(fputil::MantissaWidth<T>::value),
+                 -minExponent + int(fputil::MantissaWidth<T>::VALUE),
                  MPFR_RNDN);
 
     mpfr_sub(maxMPFR.value, maxMPFR.value, pivot.value, MPFR_RNDN);
     mpfr_mul_2si(maxMPFR.value, maxMPFR.value,
-                 -maxExponent + int(fputil::MantissaWidth<T>::value),
+                 -maxExponent + int(fputil::MantissaWidth<T>::VALUE),
                  MPFR_RNDN);
 
     mpfr_add(minMPFR.value, minMPFR.value, maxMPFR.value, MPFR_RNDN);
     return minMPFR.as<double>();
   }
 };
 
 namespace internal {

libc/utils/UnitTest/FPMatcher.h

 
 public:
   FPMatcher(T expectedValue) : expected(expectedValue) {}
 
   bool match(T actualValue) {
     actual = actualValue;
     fputil::FPBits<T> actualBits(actual), expectedBits(expected);
     if (Condition == __llvm_libc::testing::Cond_EQ)
-      return (actualBits.isNaN() && expectedBits.isNaN()) ||
+      return (actualBits.is_nan() && expectedBits.is_nan()) ||
              (actualBits.uintval() == expectedBits.uintval());
 
     // If condition == Cond_NE.
-    if (actualBits.isNaN())
-      return !expectedBits.isNaN();
-    return expectedBits.isNaN() ||
+    if (actualBits.is_nan())
+      return !expectedBits.is_nan();
+    return expectedBits.is_nan() ||
            (actualBits.uintval() != expectedBits.uintval());
   }
 
   void explainError(testutils::StreamWrapper &stream) override {
     describeValue("Expected floating point value: ", expected, stream);
     describeValue("  Actual floating point value: ", actual, stream);
   }
 };
 
 template <__llvm_libc::testing::TestCondition C, typename T>
 FPMatcher<T, C> getMatcher(T expectedValue) {
   return FPMatcher<T, C>(expectedValue);
 }
 
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc
 
 #define DECLARE_SPECIAL_CONSTANTS(T)                                           \
   using FPBits = __llvm_libc::fputil::FPBits<T>;                               \
   using UIntType = typename FPBits::UIntType;                                  \
   const T zero = T(FPBits::zero());                                            \
-  const T negZero = T(FPBits::negZero());                                      \
-  const T aNaN = T(FPBits::buildNaN(1));                                       \
+  const T neg_zero = T(FPBits::neg_zero());                                    \
+  const T aNaN = T(FPBits::build_nan(1));                                      \
   const T inf = T(FPBits::inf());                                              \
-  const T negInf = T(FPBits::negInf());
+  const T neg_inf = T(FPBits::neg_inf());
 
 #define EXPECT_FP_EQ(expected, actual)                                         \
   EXPECT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_EQ>( \
           expected))
 
 #define ASSERT_FP_EQ(expected, actual)                                         \

libc/utils/UnitTest/FPMatcher.cpp

 
 template <typename ValType>
 cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
 describeValue(const char *label, ValType value,
               testutils::StreamWrapper &stream) {
   stream << label;
 
   FPBits<ValType> bits(value);
-  if (bits.isNaN()) {
+  if (bits.is_nan()) {
     stream << "(NaN)";
-  } else if (bits.isInf()) {
-    if (bits.getSign())
+  } else if (bits.is_inf()) {
+    if (bits.get_sign())
       stream << "(-Infinity)";
     else
       stream << "(+Infinity)";
   } else {
     constexpr int exponentWidthInHex =
-        (fputil::ExponentWidth<ValType>::value - 1) / 4 + 1;
+        (fputil::ExponentWidth<ValType>::VALUE - 1) / 4 + 1;
     constexpr int mantissaWidthInHex =
-        (fputil::MantissaWidth<ValType>::value - 1) / 4 + 1;
+        (fputil::MantissaWidth<ValType>::VALUE - 1) / 4 + 1;
 
-    stream << "Sign: " << (bits.getSign() ? '1' : '0') << ", "
+    stream << "Sign: " << (bits.get_sign() ? '1' : '0') << ", "
            << "Exponent: 0x"
-           << uintToHex<uint16_t>(bits.getUnbiasedExponent(),
+           << uintToHex<uint16_t>(bits.get_unbiased_exponent(),
                                   exponentWidthInHex)
            << ", "
            << "Mantissa: 0x"
            << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.getMantissa(), mantissaWidthInHex);
+                  bits.get_mantissa(), mantissaWidthInHex);
   }
 
   stream << '\n';
 }
 
 template void describeValue<float>(const char *, float,
                                    testutils::StreamWrapper &);
 template void describeValue<double>(const char *, double,
                                     testutils::StreamWrapper &);
 template void describeValue<long double>(const char *, long double,
                                          testutils::StreamWrapper &);
 
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc