[libc][NFC] Clean up clang-tidy warnings for `src/__support` and `src/math`.

[lntue]

Summary

Clean up some warnings from running libc-lint for these folders.

[lntue]

Include exp2f.cpp.

[michaelrj]

LGTM

[sivachandra]

Do you have any resolution on the const local variable naming convention?

[lntue]

Update .clang-tidy rules for local constant cases to accept both lower_case and
UPPER_CASE.

[lntue]

In D146048#4197266, @sivachandra wrote:

Do you have any resolution on the const local variable naming convention?

I've updated clang-tidy rules to accept both lower_case and UPPER_CASE for local constants.

[sivachandra]

libc/.clang-tidy

12

Why is this (and two more below) changed?

23

I suppose that if you don't add these, then the VariableCase complains about UPPER_CASE names. But, once you add this LocalConstantCase, it complains about const function args also and so you have to add LocalConstantIgnoredRegexp?

[lntue]

Simplify the LocalConstant rules a bit.

libc/.clang-tidy

12

These will make the rule a bit stricter by preventing trailing _'s in the names.

23

I didn't look at VariableCase. I guess I could simplify this a bit by using LocalConstantIngoredRegexp to allow UPPER_CASE, and using VariableCase for lower_case.

[sivachandra]

libc/.clang-tidy

23

We already have VariableCase above on line 13, no?

[lntue]

libc/.clang-tidy

23

Yes, that's why I removed LocalConstantCase and changed LocalConstantIgnoredRegexp to allow UPPER_CASE instead.

[sivachandra]

libc/.clang-tidy

23

Ah, you mean't you did not "notice" VariableCase.

libc/.clang-tidy

 InheritParentConfig: false
 Checks: 'readability-identifier-naming'
 HeaderFilterRegex: '.*'
 CheckOptions:
   - key:             readability-identifier-naming.ClassCase
     value:           CamelCase
   - key:             readability-identifier-naming.StructCase
     value:           aNy_CasE
   - key:             readability-identifier-naming.MemberCase
     value:           lower_case
   - key:             readability-identifier-naming.MemberIgnoredRegexp
-    value:           "^_[A-Za-z0-9_]+$"
+    value:           "_?(_[A-Za-z0-9]+)*"
   - key:             readability-identifier-naming.VariableCase
     value:           lower_case
   - key:             readability-identifier-naming.VariableIgnoredRegexp
-    value:           "^_[A-Za-z0-9_]+$"
+    value:           "_?(_[A-Za-z0-9]+)*"
   - key:             readability-identifier-naming.FunctionCase
     value:           lower_case
   - key:             readability-identifier-naming.FunctionIgnoredRegexp
-    value:           "^_[A-Za-z0-9_]+$"
+    value:           "_?(_[A-Za-z0-9]+)*"
   - key:             readability-identifier-naming.GlobalConstantCase
     value:           UPPER_CASE
+  - key:             readability-identifier-naming.LocalConstantCase
+    value:           UPPER_CASE
+  - key:             readability-identifier-naming.LocalConstantIgnoredRegexp
+    value:           "[a-z]+[a-z0-9]*(_[a-z0-9]+)*"
+  - key:             readability-identifier-naming.ClassConstantCase
+    value:           UPPER_CASE
   - key:             readability-identifier-naming.ConstexprVariableCase
     value:           UPPER_CASE
   - key:             readability-identifier-naming.GetConfigPerFile
     value:           true

libc/src/__support/FPUtil/XFloat.h

 
 namespace __llvm_libc {
 namespace fputil {
 
 // Store and manipulate positive double precision numbers at |Precision| bits.
 template <size_t Precision> class XFloat {
   static constexpr uint64_t OneMask = (uint64_t(1) << 63);
   UInt<Precision> man;
-  static constexpr uint64_t WordCount = Precision / 64;
+  static constexpr uint64_t WORDCOUNT = Precision / 64;
   int exp;
 
   size_t bit_width(uint64_t x) {
     if (x == 0)
       return 0;
     size_t shift = 0;
     while ((OneMask & x) == 0) {
       ++shift;
       x <<= 1;
     }
     return 64 - shift;
   }
 
 public:
   XFloat() : exp(0) {
-    for (int i = 0; i < WordCount; ++i)
+    for (int i = 0; i < WORDCOUNT; ++i)
       man[i] = 0;
   }
 
   XFloat(const XFloat &other) : exp(other.exp) {
-    for (int i = 0; i < WordCount; ++i)
+    for (int i = 0; i < WORDCOUNT; ++i)
       man[i] = other.man[i];
   }
 
   explicit XFloat(double x) {
     auto xn = NormalFloat<double>(x);
     exp = xn.exponent;
-    man[WordCount - 1] = xn.mantissa << 11;
-    for (int i = 0; i < WordCount - 1; ++i)
+    man[WORDCOUNT - 1] = xn.mantissa << 11;
+    for (int i = 0; i < WORDCOUNT - 1; ++i)
       man[i] = 0;
   }
 
   XFloat(int e, const UInt<Precision> &bits) : exp(e) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       man[i] = bits[i];
   }
 
   // Multiply this number with x and store the result in this number.
   void mul(double x) {
     auto xn = NormalFloat<double>(x);
     exp += xn.exponent;
     uint64_t carry = man.mul(xn.mantissa << 11);
     size_t carry_width = bit_width(carry);
     carry_width = (carry_width == 64 ? 64 : 63);
     man.shift_right(carry_width);
-    man[WordCount - 1] = man[WordCount - 1] + (carry << (64 - carry_width));
+    man[WORDCOUNT - 1] = man[WORDCOUNT - 1] + (carry << (64 - carry_width));
     exp += carry_width == 64 ? 1 : 0;
     normalize();
   }
 
   void drop_int() {
     if (exp < 0)
       return;
     if (exp > int(Precision - 1)) {
-      for (size_t i = 0; i < WordCount; ++i)
+      for (size_t i = 0; i < WORDCOUNT; ++i)
         man[i] = 0;
       return;
     }
 
     man.shift_left(exp + 1);
     man.shift_right(exp + 1);
 
     normalize();
   }
 
   double mul(const XFloat<Precision> &other) {
-    constexpr size_t row_words = 2 * WordCount + 1;
+    constexpr size_t row_words = 2 * WORDCOUNT + 1;
     constexpr size_t row_precision = row_words * 64;
     constexpr size_t result_bits = 2 * Precision;
-    UInt<row_precision> rows[WordCount];
+    UInt<row_precision> rows[WORDCOUNT];
 
-    for (size_t r = 0; r < WordCount; ++r) {
+    for (size_t r = 0; r < WORDCOUNT; ++r) {
       for (size_t i = 0; i < row_words; ++i) {
-        if (i < WordCount)
+        if (i < WORDCOUNT)
           rows[r][i] = man[i];
         else
           rows[r][i] = 0;
       }
       rows[r].mul(other.man[r]);
       rows[r].shift_left(r * 64);
     }
 
-    for (size_t r = 1; r < WordCount; ++r) {
+    for (size_t r = 1; r < WORDCOUNT; ++r) {
       rows[0].add(rows[r]);
     }
     int result_exp = exp + other.exp;
     uint64_t carry = rows[0][row_words - 1];
     if (carry) {
       size_t carry_width = bit_width(carry);
       rows[0].shift_right(carry_width);
       rows[0][row_words - 2] =
double mul(const XFloat<Precision> &other) {
     return double(result);
   }
 
   explicit operator double() {
     normalize();
 
     constexpr uint64_t one = uint64_t(1) << 10;
     constexpr uint64_t excess_mask = (one << 1) - 1;
-    uint64_t excess = man[WordCount - 1] & excess_mask;
-    uint64_t new_man = man[WordCount - 1] >> 11;
+    uint64_t excess = man[WORDCOUNT - 1] & excess_mask;
+    uint64_t new_man = man[WORDCOUNT - 1] >> 11;
     if (excess > one) {
       // We have to round up.
       ++new_man;
     } else if (excess == one) {
       bool greater_than_one = false;
-      for (size_t i = 0; i < WordCount - 1; ++i) {
+      for (size_t i = 0; i < WORDCOUNT - 1; ++i) {
         greater_than_one = (man[i] != 0);
         if (greater_than_one)
           break;
       }
       if (greater_than_one || (new_man & 1) != 0) {
         ++new_man;
       }
     }
 
     if (new_man == (uint64_t(1) << 53))
       ++exp;
 
     // We use NormalFloat as it can produce subnormal numbers or underflow to 0
     // if necessary.
     NormalFloat<double> d(exp, new_man, 0);
     return double(d);
   }
 
   // Normalizes this number.
   void normalize() {
     uint64_t man_bits = 0;
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       man_bits |= man[i];
 
     if (man_bits == 0)
       return;
 
-    while ((man[WordCount - 1] & OneMask) == 0) {
+    while ((man[WORDCOUNT - 1] & OneMask) == 0) {
       man.shift_left(1);
       --exp;
     }
   }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc

libc/src/__support/FPUtil/dyadic_float.h

explicit operator T() const {
     constexpr size_t PRECISION = FloatProperties<T>::MANTISSA_WIDTH + 1;
     using output_bits_t = typename FPBits<T>::UIntType;
 
     MantissaType m_hi(mantissa >> (Bits - PRECISION));
     auto d_hi = FPBits<T>::create_value(
         sign, exponent + (Bits - 1) + FloatProperties<T>::EXPONENT_BIAS,
         output_bits_t(m_hi) & FloatProperties<T>::MANTISSA_MASK);
 
-    const MantissaType ROUND_MASK = MantissaType(1) << (Bits - PRECISION - 1);
-    const MantissaType STICKY_MASK = ROUND_MASK - MantissaType(1);
+    const MantissaType round_mask = MantissaType(1) << (Bits - PRECISION - 1);
+    const MantissaType sticky_mask = round_mask - MantissaType(1);
 
-    bool round_bit = !(mantissa & ROUND_MASK).is_zero();
-    bool sticky_bit = !(mantissa & STICKY_MASK).is_zero();
+    bool round_bit = !(mantissa & round_mask).is_zero();
+    bool sticky_bit = !(mantissa & sticky_mask).is_zero();
     int round_and_sticky = int(round_bit) * 2 + int(sticky_bit);
     auto d_lo = FPBits<T>::create_value(sign,
                                         exponent + (Bits - PRECISION - 2) +
                                             FloatProperties<T>::EXPONENT_BIAS,
                                         output_bits_t(0));
 
     // Still correct without FMA instructions if `d_lo` is not underflow.
     return multiply_add(d_lo.get_val(), T(round_and_sticky), d_hi.get_val());
constexpr DyadicFloat<Bits> quick_add(DyadicFloat<Bits> a,
   if (a.sign == b.sign) {
     // Addition
     result.sign = a.sign;
     result.exponent = a.exponent;
     result.mantissa = a.mantissa;
     if (result.mantissa.add(b.mantissa)) {
       // Mantissa addition overflow.
       result.shift_right(1);
-      result.mantissa.val[DyadicFloat<Bits>::MantissaType::WordCount - 1] |=
+      result.mantissa.val[DyadicFloat<Bits>::MantissaType::WORDCOUNT - 1] |=
           (uint64_t(1) << 63);
     }
     // Result is already normalized.
     return result;
   }
 
   // Subtraction
   if (a.mantissa >= b.mantissa) {

 }
 
 // Quick Mul - Slightly less accurate but efficient multiplication of 2 dyadic
 // floats with rounding toward 0 and then normalize the output:
 //   result.exponent = a.exponent + b.exponent + Bits,
 //   result.mantissa = quick_mul_hi(a.mantissa + b.mantissa)
 //                   ~ (full product a.mantissa * b.mantissa) >> Bits.
 // The errors compared to the mathematical product is bounded by:
-//   2 * errors of quick_mul_hi = 2 * (UInt<Bits>::WordCount - 1) in ULPs.
+//   2 * errors of quick_mul_hi = 2 * (UInt<Bits>::WORDCOUNT - 1) in ULPs.
 // Assume inputs are normalized (by constructors or other functions) so that we
 // don't need to normalize the inputs again in this function.  If the inputs are
 // not normalized, the results might lose precision significantly.
 template <size_t Bits>
 constexpr DyadicFloat<Bits> quick_mul(DyadicFloat<Bits> a,
                                       DyadicFloat<Bits> b) {
   DyadicFloat<Bits> result;
   result.sign = (a.sign != b.sign);
   result.exponent = a.exponent + b.exponent + int(Bits);
 
   if (!(a.mantissa.is_zero() || b.mantissa.is_zero())) {
     result.mantissa = a.mantissa.quick_mul_hi(b.mantissa);
     // Check the leading bit directly, should be faster than using clz in
     // normalize().
-    if (result.mantissa.val[DyadicFloat<Bits>::MantissaType::WordCount - 1] >>
+    if (result.mantissa.val[DyadicFloat<Bits>::MantissaType::WORDCOUNT - 1] >>
             63 ==
         0)
       result.shift_left(1);
   } else {
     result.mantissa = (typename DyadicFloat<Bits>::MantissaType)(0);
   }
   return result;
 }
 
 } // namespace __llvm_libc::fputil
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DYADIC_FLOAT_H

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

 // be implemented in another handler.
 // Signaling NaN converted to quiet NaN with FE_INVALID exception.
 //    https://www.open-std.org/JTC1/SC22/WG14/www/docs/n1011.htm
 template <typename T> struct FModExceptionalInputHandler {
 
   static_assert(cpp::is_floating_point_v<T>,
                 "FModCStandardWrapper instantiated with invalid type.");
 
-  LIBC_INLINE static bool PreCheck(T x, T y, T &out) {
+  LIBC_INLINE static bool pre_check(T x, T y, T &out) {
     using FPB = fputil::FPBits<T>;
-    const T quiet_NaN = FPB::build_quiet_nan(0);
+    const T quiet_nan = FPB::build_quiet_nan(0);
     FPB sx(x), sy(y);
     if (LIBC_LIKELY(!sy.is_zero() && !sy.is_inf_or_nan() &&
                     !sx.is_inf_or_nan())) {
       return false;
     }
 
     if (sx.is_nan() || sy.is_nan()) {
       if ((sx.is_nan() && !sx.is_quiet_nan()) ||
           (sy.is_nan() && !sy.is_quiet_nan()))
-        fputil::set_except(FE_INVALID);
-      out = quiet_NaN;
+        fputil::raise_except_if_required(FE_INVALID);
+      out = quiet_nan;
       return true;
     }
 
     if (sx.is_inf() || sy.is_zero()) {
-      fputil::set_except(FE_INVALID);
-      out = with_errno(quiet_NaN, EDOM);
+      fputil::raise_except_if_required(FE_INVALID);
+      fputil::set_errno_if_required(EDOM);
+      out = quiet_nan;
       return true;
     }
 
     if (sy.is_inf()) {
       out = x;
       return true;
     }
 
     // case where x == 0
     out = x;
     return true;
   }
 };
 
 template <typename T> struct FModFastMathWrapper {
 
   static_assert(cpp::is_floating_point_v<T>,
                 "FModFastMathWrapper instantiated with invalid type.");
 
-  static bool PreCheck(T, T, T &) { return false; }
+  static bool pre_check(T, T, T &) { return false; }
 };
 
 template <typename T> class FModDivisionSimpleHelper {
 private:
   using intU_t = typename FPBits<T>::UIntType;
 
 public:
   LIBC_INLINE constexpr static intU_t
LIBC_INLINE static constexpr FPB eval_internal(FPB sx, FPB sy) {
 
     /* hx next can't be 0, because hx < hy, hy % 2 == 1 hx * 2^i % hy != 0 */
     m_x = DivisionHelper::execute(exp_diff, sides_zeroes_count, m_x, m_y);
     return FPB::make_value(m_x, e_y);
   }
 
 public:
   LIBC_INLINE static T eval(T x, T y) {
-    if (T out; Wrapper::PreCheck(x, y, out))
+    if (T out; Wrapper::pre_check(x, y, out))
       return out;
     FPB sx(x), sy(y);
     bool sign = sx.get_sign();
     sx.set_sign(false);
     sy.set_sign(false);
     FPB result = eval_internal(sx, sy);
     result.set_sign(sign);
     return result.get_val();
   }
 };
 
 } // namespace generic
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMOD_H

libc/src/__support/UInt.h

 #include <stdint.h>
 
 namespace __llvm_libc::cpp {
 
 template <size_t Bits> struct UInt {
 
   static_assert(Bits > 0 && Bits % 64 == 0,
                 "Number of bits in UInt should be a multiple of 64.");
-  static constexpr size_t WordCount = Bits / 64;
-  uint64_t val[WordCount];
+  static constexpr size_t WORDCOUNT = Bits / 64;
+  uint64_t val[WORDCOUNT];
 
   static constexpr uint64_t MASK32 = 0xFFFFFFFFu;
 
   static constexpr uint64_t low(uint64_t v) { return v & MASK32; }
   static constexpr uint64_t high(uint64_t v) { return (v >> 32) & MASK32; }
 
   constexpr UInt() {}
 
   constexpr UInt(const UInt<Bits> &other) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] = other.val[i];
   }
 
   template <size_t OtherBits> constexpr UInt(const UInt<OtherBits> &other) {
     if (OtherBits >= Bits) {
-      for (size_t i = 0; i < WordCount; ++i)
+      for (size_t i = 0; i < WORDCOUNT; ++i)
         val[i] = other[i];
     } else {
       size_t i = 0;
       for (; i < OtherBits / 64; ++i)
         val[i] = other[i];
-      for (; i < WordCount; ++i)
+      for (; i < WORDCOUNT; ++i)
         val[i] = 0;
     }
   }
 
   // Construct a UInt from a C array.
-  template <size_t N, enable_if_t<N <= WordCount, int> = 0>
+  template <size_t N, enable_if_t<N <= WORDCOUNT, int> = 0>
   constexpr UInt(const uint64_t (&nums)[N]) {
-    size_t min_wordcount = N < WordCount ? N : WordCount;
+    size_t min_wordcount = N < WORDCOUNT ? N : WORDCOUNT;
     size_t i = 0;
     for (; i < min_wordcount; ++i)
       val[i] = nums[i];
 
     // If nums doesn't completely fill val, then fill the rest with zeroes.
-    for (; i < WordCount; ++i)
+    for (; i < WORDCOUNT; ++i)
       val[i] = 0;
   }
 
   // Initialize the first word to |v| and the rest to 0.
   constexpr UInt(uint64_t v) {
     val[0] = v;
-    for (size_t i = 1; i < WordCount; ++i) {
+    for (size_t i = 1; i < WORDCOUNT; ++i) {
       val[i] = 0;
     }
   }
-  constexpr explicit UInt(const cpp::array<uint64_t, WordCount> &words) {
-    for (size_t i = 0; i < WordCount; ++i)
+  constexpr explicit UInt(const cpp::array<uint64_t, WORDCOUNT> &words) {
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] = words[i];
   }
 
   constexpr explicit operator uint64_t() const { return val[0]; }
 
   constexpr explicit operator uint32_t() const {
     return uint32_t(uint64_t(*this));
   }
 
   constexpr explicit operator uint8_t() const {
     return uint8_t(uint64_t(*this));
   }
 
   UInt<Bits> &operator=(const UInt<Bits> &other) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] = other.val[i];
     return *this;
   }
 
   constexpr bool is_zero() const {
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != 0)
         return false;
     }
     return true;
   }
 
   // Add x to this number and store the result in this number.
   // Returns the carry value produced by the addition operation.
   constexpr uint64_t add(const UInt<Bits> &x) {
     SumCarry<uint64_t> s{0, 0};
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       s = add_with_carry(val[i], x.val[i], s.carry);
       val[i] = s.sum;
     }
     return s.carry;
   }
 
   constexpr UInt<Bits> operator+(const UInt<Bits> &other) const {
     UInt<Bits> result;
     SumCarry<uint64_t> s{0, 0};
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       s = add_with_carry(val[i], other.val[i], s.carry);
       result.val[i] = s.sum;
     }
     return result;
   }
 
   constexpr UInt<Bits> &operator+=(const UInt<Bits> &other) {
     add(other); // Returned carry value is ignored.
     return *this;
   }
 
   // Subtract x to this number and store the result in this number.
   // Returns the carry value produced by the subtraction operation.
   constexpr uint64_t sub(const UInt<Bits> &x) {
     DiffBorrow<uint64_t> d{0, 0};
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       d = sub_with_borrow(val[i], x.val[i], d.borrow);
       val[i] = d.diff;
     }
     return d.borrow;
   }
 
   constexpr UInt<Bits> operator-(const UInt<Bits> &other) const {
     UInt<Bits> result;
     DiffBorrow<uint64_t> d{0, 0};
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       d = sub_with_borrow(val[i], other.val[i], d.borrow);
       result.val[i] = d.diff;
     }
     return result;
   }
 
   constexpr UInt<Bits> &operator-=(const UInt<Bits> &other) {
     // TODO(lntue): Set overflow flag / errno when carry is true.
     sub(other);
     return *this;
   }
 
   // Multiply this number with x and store the result in this number. It is
   // implemented using the long multiplication algorithm by splitting the
   // 64-bit words of this number and |x| in to 32-bit halves but peforming
   // the operations using 64-bit numbers. This ensures that we don't lose the
   // carry bits.
   // Returns the carry value produced by the multiplication operation.
   constexpr uint64_t mul(uint64_t x) {
     UInt<128> partial_sum(0);
     uint64_t carry = 0;
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       NumberPair<uint64_t> prod = full_mul(val[i], x);
       UInt<128> tmp({prod.lo, prod.hi});
       carry += partial_sum.add(tmp);
       val[i] = partial_sum.val[0];
       partial_sum.val[0] = partial_sum.val[1];
       partial_sum.val[1] = carry;
       carry = 0;
     }
     return partial_sum.val[1];
   }
 
   constexpr UInt<Bits> operator*(const UInt<Bits> &other) const {
-    if constexpr (WordCount == 1) {
+    if constexpr (WORDCOUNT == 1) {
       return {val[0] * other.val[0]};
     } else {
       UInt<Bits> result(0);
       UInt<128> partial_sum(0);
       uint64_t carry = 0;
-      for (size_t i = 0; i < WordCount; ++i) {
+      for (size_t i = 0; i < WORDCOUNT; ++i) {
         for (size_t j = 0; j <= i; j++) {
           NumberPair<uint64_t> prod = full_mul(val[j], other.val[i - j]);
           UInt<128> tmp({prod.lo, prod.hi});
           carry += partial_sum.add(tmp);
         }
         result.val[i] = partial_sum.val[0];
         partial_sum.val[0] = partial_sum.val[1];
         partial_sum.val[1] = carry;
         carry = 0;
       }
       return result;
     }
   }
 
   // Return the full product.
   template <size_t OtherBits>
   constexpr UInt<Bits + OtherBits> ful_mul(const UInt<OtherBits> &other) const {
     UInt<Bits + OtherBits> result(0);
     UInt<128> partial_sum(0);
     uint64_t carry = 0;
-    constexpr size_t OtherWordCount = UInt<OtherBits>::WordCount;
-    for (size_t i = 0; i <= WordCount + OtherWordCount - 2; ++i) {
-      const size_t lower_idx = i < OtherWordCount ? 0 : i - OtherWordCount + 1;
-      const size_t upper_idx = i < WordCount ? i : WordCount - 1;
+    constexpr size_t OTHER_WORDCOUNT = UInt<OtherBits>::WORDCOUNT;
+    for (size_t i = 0; i <= WORDCOUNT + OTHER_WORDCOUNT - 2; ++i) {
+      const size_t lower_idx =
+          i < OTHER_WORDCOUNT ? 0 : i - OTHER_WORDCOUNT + 1;
+      const size_t upper_idx = i < WORDCOUNT ? i : WORDCOUNT - 1;
       for (size_t j = lower_idx; j <= upper_idx; ++j) {
         NumberPair<uint64_t> prod = full_mul(val[j], other.val[i - j]);
         UInt<128> tmp({prod.lo, prod.hi});
         carry += partial_sum.add(tmp);
       }
       result.val[i] = partial_sum.val[0];
       partial_sum.val[0] = partial_sum.val[1];
       partial_sum.val[1] = carry;
       carry = 0;
     }
-    result.val[WordCount + OtherWordCount - 1] = partial_sum.val[0];
+    result.val[WORDCOUNT + OTHER_WORDCOUNT - 1] = partial_sum.val[0];
     return result;
   }
 
   // Fast hi part of the full product.  The normal product `operator*` returns
   // `Bits` least significant bits of the full product, while this function will
   // approximate `Bits` most significant bits of the full product with errors
   // bounded by:
-  //   0 <= (a.full_mul(b) >> Bits) - a.quick_mul_hi(b)) <= WordCount - 1.
+  //   0 <= (a.full_mul(b) >> Bits) - a.quick_mul_hi(b)) <= WORDCOUNT - 1.
   //
   // An example usage of this is to quickly (but less accurately) compute the
   // product of (normalized) mantissas of floating point numbers:
   //   (mant_1, mant_2) -> quick_mul_hi -> normalize leading bit
   // is much more efficient than:
   //   (mant_1, mant_2) -> ful_mul -> normalize leading bit
   //                    -> convert back to same Bits width by shifting/rounding,
   // especially for higher precisions.
   //
   // Performance summary:
   //   Number of 64-bit x 64-bit -> 128-bit multiplications performed.
-  //   Bits  WordCount  ful_mul  quick_mul_hi  Error bound
+  //   Bits  WORDCOUNT  ful_mul  quick_mul_hi  Error bound
   //    128      2         4           3            1
   //    196      3         9           6            2
   //    256      4        16          10            3
   //    512      8        64          36            7
   constexpr UInt<Bits> quick_mul_hi(const UInt<Bits> &other) const {
     UInt<Bits> result(0);
     UInt<128> partial_sum(0);
     uint64_t carry = 0;
-    // First round of accumulation for those at WordCount - 1 in the full
+    // First round of accumulation for those at WORDCOUNT - 1 in the full
     // product.
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       NumberPair<uint64_t> prod =
-          full_mul(val[i], other.val[WordCount - 1 - i]);
+          full_mul(val[i], other.val[WORDCOUNT - 1 - i]);
       UInt<128> tmp({prod.lo, prod.hi});
       carry += partial_sum.add(tmp);
     }
-    for (size_t i = WordCount; i < 2 * WordCount - 1; ++i) {
+    for (size_t i = WORDCOUNT; i < 2 * WORDCOUNT - 1; ++i) {
       partial_sum.val[0] = partial_sum.val[1];
       partial_sum.val[1] = carry;
       carry = 0;
-      for (size_t j = i - WordCount + 1; j < WordCount; ++j) {
+      for (size_t j = i - WORDCOUNT + 1; j < WORDCOUNT; ++j) {
         NumberPair<uint64_t> prod = full_mul(val[j], other.val[i - j]);
         UInt<128> tmp({prod.lo, prod.hi});
         carry += partial_sum.add(tmp);
       }
-      result.val[i - WordCount] = partial_sum.val[0];
+      result.val[i - WORDCOUNT] = partial_sum.val[0];
     }
-    result.val[WordCount - 1] = partial_sum.val[1];
+    result.val[WORDCOUNT - 1] = partial_sum.val[1];
     return result;
   }
 
   // pow takes a power and sets this to its starting value to that power. Zero
   // to the zeroth power returns 1.
   constexpr void pow_n(uint64_t power) {
     UInt<Bits> result = 1;
     UInt<Bits> cur_power = *this;
template <size_t Bits> struct UInt {
 
   constexpr UInt<Bits> &operator*=(const UInt<Bits> &other) {
     *this = *this * other;
     return *this;
   }
 
   constexpr uint64_t clz() {
     uint64_t leading_zeroes = 0;
-    for (size_t i = WordCount; i > 0; --i) {
+    for (size_t i = WORDCOUNT; i > 0; --i) {
       if (val[i - 1] == 0) {
         leading_zeroes += sizeof(uint64_t) * 8;
       } else {
         leading_zeroes += unsafe_clz(val[i - 1]);
         break;
       }
     }
     return leading_zeroes;
if constexpr (Bits == 128) {
       return;
     }
 #endif // __SIZEOF_INT128__
     if (LIBC_UNLIKELY(s == 0))
       return;
 
     const size_t drop = s / 64;  // Number of words to drop
     const size_t shift = s % 64; // Bits to shift in the remaining words.
-    size_t i = WordCount;
+    size_t i = WORDCOUNT;
 
-    if (drop < WordCount) {
-      i = WordCount - 1;
+    if (drop < WORDCOUNT) {
+      i = WORDCOUNT - 1;
       if (shift > 0) {
-        for (size_t j = WordCount - 1 - drop; j > 0; --i, --j) {
+        for (size_t j = WORDCOUNT - 1 - drop; j > 0; --i, --j) {
           val[i] = (val[j] << shift) | (val[j - 1] >> (64 - shift));
         }
         val[i] = val[0] << shift;
       } else {
-        for (size_t j = WordCount - 1 - drop; j > 0; --i, --j) {
+        for (size_t j = WORDCOUNT - 1 - drop; j > 0; --i, --j) {
           val[i] = val[j];
         }
         val[i] = val[0];
       }
     }
 
     for (size_t j = 0; j < i; ++j) {
       val[j] = 0;
#endif // __SIZEOF_INT128__
 
     if (LIBC_UNLIKELY(s == 0))
       return;
     const size_t drop = s / 64;  // Number of words to drop
     const size_t shift = s % 64; // Bit shift in the remaining words.
 
     size_t i = 0;
 
-    if (drop < WordCount) {
+    if (drop < WORDCOUNT) {
       if (shift > 0) {
-        for (size_t j = drop; j < WordCount - 1; ++i, ++j) {
+        for (size_t j = drop; j < WORDCOUNT - 1; ++i, ++j) {
           val[i] = (val[j] >> shift) | (val[j + 1] << (64 - shift));
         }
-        val[i] = val[WordCount - 1] >> shift;
+        val[i] = val[WORDCOUNT - 1] >> shift;
         ++i;
       } else {
-        for (size_t j = drop; j < WordCount; ++i, ++j) {
+        for (size_t j = drop; j < WORDCOUNT; ++i, ++j) {
           val[i] = val[j];
         }
       }
     }
 
-    for (; i < WordCount; ++i) {
+    for (; i < WORDCOUNT; ++i) {
       val[i] = 0;
     }
   }
 
   constexpr UInt<Bits> operator>>(size_t s) const {
     UInt<Bits> result(*this);
     result.shift_right(s);
     return result;
   }
 
   constexpr UInt<Bits> &operator>>=(size_t s) {
     shift_right(s);
     return *this;
   }
 
   constexpr UInt<Bits> operator&(const UInt<Bits> &other) const {
     UInt<Bits> result;
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] & other.val[i];
     return result;
   }
 
   constexpr UInt<Bits> &operator&=(const UInt<Bits> &other) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] &= other.val[i];
     return *this;
   }
 
   constexpr UInt<Bits> operator|(const UInt<Bits> &other) const {
     UInt<Bits> result;
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] | other.val[i];
     return result;
   }
 
   constexpr UInt<Bits> &operator|=(const UInt<Bits> &other) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] |= other.val[i];
     return *this;
   }
 
   constexpr UInt<Bits> operator^(const UInt<Bits> &other) const {
     UInt<Bits> result;
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] ^ other.val[i];
     return result;
   }
 
   constexpr UInt<Bits> &operator^=(const UInt<Bits> &other) {
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] ^= other.val[i];
     return *this;
   }
 
   constexpr UInt<Bits> operator~() const {
     UInt<Bits> result;
-    for (size_t i = 0; i < WordCount; ++i)
+    for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = ~val[i];
     return result;
   }
 
   constexpr bool operator==(const UInt<Bits> &other) const {
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != other.val[i])
         return false;
     }
     return true;
   }
 
   constexpr bool operator!=(const UInt<Bits> &other) const {
-    for (size_t i = 0; i < WordCount; ++i) {
+    for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != other.val[i])
         return true;
     }
     return false;
   }
 
   constexpr bool operator>(const UInt<Bits> &other) const {
-    for (size_t i = WordCount; i > 0; --i) {
+    for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return true;
       else if (word < other_word)
         return false;
     }
     // Equal
     return false;
   }
 
   constexpr bool operator>=(const UInt<Bits> &other) const {
-    for (size_t i = WordCount; i > 0; --i) {
+    for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return true;
       else if (word < other_word)
         return false;
     }
     // Equal
     return true;
   }
 
   constexpr bool operator<(const UInt<Bits> &other) const {
-    for (size_t i = WordCount; i > 0; --i) {
+    for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return false;
       else if (word < other_word)
         return true;
     }
     // Equal
     return false;
   }
 
   constexpr bool operator<=(const UInt<Bits> &other) const {
-    for (size_t i = WordCount; i > 0; --i) {
+    for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return false;
       else if (word < other_word)
         return true;
     }
     // Equal

libc/src/math/generic/exp2f.cpp

 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 
 #include <errno.h>
 
 #include "explogxf.h"
 
 namespace __llvm_libc {
 
-constexpr uint32_t exval1 = 0x3b42'9d37U;
-constexpr uint32_t exval2 = 0xbcf3'a937U;
-constexpr uint32_t exval_mask = exval1 & exval2;
+constexpr uint32_t EXVAL1 = 0x3b42'9d37U;
+constexpr uint32_t EXVAL2 = 0xbcf3'a937U;
+constexpr uint32_t EXVAL_MASK = EXVAL1 & EXVAL2;
 
 LLVM_LIBC_FUNCTION(float, exp2f, (float x)) {
   using FPBits = typename fputil::FPBits<float>;
   FPBits xbits(x);
 
   uint32_t x_u = xbits.uintval();
   uint32_t x_abs = x_u & 0x7fff'ffffU;
 
if (x_u >= 0xc316'0000U) {
         fputil::set_errno_if_required(ERANGE);
         fputil::raise_except_if_required(FE_UNDERFLOW);
       }
       return 0.0f;
     }
   }
 
   // Check exceptional values.
-  if (LIBC_UNLIKELY((x_u & exval_mask) == exval_mask)) {
-    if (LIBC_UNLIKELY(x_u == exval1)) { // x = 0x1.853a6ep-9f
+  if (LIBC_UNLIKELY((x_u & EXVAL_MASK) == EXVAL_MASK)) {
+    if (LIBC_UNLIKELY(x_u == EXVAL1)) { // x = 0x1.853a6ep-9f
       if (fputil::get_round() == FE_TONEAREST)
         return 0x1.00870ap+0f;
-    } else if (LIBC_UNLIKELY(x_u == exval2)) { // x = -0x1.e7526ep-6f
+    } else if (LIBC_UNLIKELY(x_u == EXVAL2)) { // x = -0x1.e7526ep-6f
       if (fputil::get_round() == FE_TONEAREST)
         return 0x1.f58d62p-1f;
     }
   }
 
   // For -150 < x < 128, to compute 2^x, we perform the following range
   // reduction: find hi, mid, lo such that:
   //   x = hi + mid + lo, in which

libc/src/math/generic/log10.cpp

double log10_accurate(int e_x, int index, double m_x) {
   Float192 e_x_f192(static_cast<float>(e_x));
   Float192 sum = fputil::quick_add(LOG10_R_F192[index],
                                    fputil::quick_mul(LOG10_2, e_x_f192));
 
   fputil::DoubleDouble mx{/*lo*/ 0.0, /*hi*/ m_x};
 
   // Further range reductions.
   double scale = 0x1.0p+7;
-  const fputil::DyadicFloat<128> NEG_ONE(-1.0);
   for (size_t i = 0; i < R_STEPS; ++i) {
     scale *= 0x1.0p+4;
     int id = static_cast<int>(fputil::multiply_add(mx.hi, scale, 0x1.0p+4));
     double r = RR[i][id];
     fputil::DoubleDouble rm = fputil::exact_mult(r, mx.hi);
     rm.hi += r - 1.0;
     rm.lo = fputil::multiply_add(r, mx.lo, rm.lo);
     mx = fputil::exact_add(rm.hi, rm.lo);

libc/utils/HdrGen/PrototypeTestGen/.clang-tidy

-CheckOptions:
-  - key:             readability-identifier-naming.VariableCase
-    value:           camelBack