[libc] Add a naming rule for global constants.

[michaelrj]

LGTM except for libc/src/__support/FPUtil/aarch64/FEnvImpl.h, which needs a formatting pass.

[sivachandra]

Fix format in aarch64/FEnvImpl.h

[sivachandra]

Fix a typo.

[michaelrj]

LGTM

[sivachandra]

The file aarch64/FEnvImpl.h requires more formatting changes which I will do in a follow up change. I have addressed only global constant formatting in this patch.

libc/.clang-tidy

CheckOptions:
   - key:             readability-identifier-naming.VariableCase
     value:           lower_case
   - key:             readability-identifier-naming.VariableIgnoredRegexp
     value:           "^_[A-Za-z0-9_]+$"
   - key:             readability-identifier-naming.FunctionCase
     value:           lower_case
   - key:             readability-identifier-naming.FunctionIgnoredRegexp
     value:           "^_[A-Za-z0-9_]+$"
+  - key:             readability-identifier-naming.GlobalConstantCase
+    value:           UPPER_CASE
   - key:             readability-identifier-naming.ConstexprVariableCase
     value:           UPPER_CASE
   - key:             readability-identifier-naming.GetConfigPerFile
     value:           true

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

struct FPState {
     uint32_t ControlWord;
     uint32_t StatusWord;
   };
 
   static_assert(
       sizeof(fenv_t) == sizeof(FPState),
       "Internal floating point state does not match the public fenv_t type.");
 
-  static constexpr uint32_t ToNearest = 0x0;
-  static constexpr uint32_t Upward = 0x1;
-  static constexpr uint32_t Downward = 0x2;
-  static constexpr uint32_t TowardZero = 0x3;
-
-  static constexpr uint32_t Invalid = 0x1;
-  static constexpr uint32_t DivByZero = 0x2;
-  static constexpr uint32_t Overflow = 0x4;
-  static constexpr uint32_t Underflow = 0x8;
-  static constexpr uint32_t Inexact = 0x10;
+  static constexpr uint32_t TONEAREST = 0x0;
+  static constexpr uint32_t UPWARD = 0x1;
+  static constexpr uint32_t DOWNWARD = 0x2;
+  static constexpr uint32_t TOWARDZERO = 0x3;
+
+  static constexpr uint32_t INVALID = 0x1;
+  static constexpr uint32_t DIVBYZERO = 0x2;
+  static constexpr uint32_t OVERFLOW = 0x4;
+  static constexpr uint32_t UNDERFLOW = 0x8;
+  static constexpr uint32_t INEXACT = 0x10;
 
   // Zero-th bit is the first bit.
   static constexpr uint32_t RoundingControlBitPosition = 22;
   static constexpr uint32_t ExceptionStatusFlagsBitPosition = 0;
   static constexpr uint32_t ExceptionControlFlagsBitPosition = 8;
 
   static inline uint32_t getStatusValueForExcept(int excepts) {
-    return (excepts & FE_INVALID ? Invalid : 0) |
-           (excepts & FE_DIVBYZERO ? DivByZero : 0) |
-           (excepts & FE_OVERFLOW ? Overflow : 0) |
-           (excepts & FE_UNDERFLOW ? Underflow : 0) |
-           (excepts & FE_INEXACT ? Inexact : 0);
+    return (excepts & FE_INVALID ? INVALID : 0) |
+           (excepts & FE_DIVBYZERO ? DIVBYZERO : 0) |
+           (excepts & FE_OVERFLOW ? OVERFLOW : 0) |
+           (excepts & FE_UNDERFLOW ? UNDERFLOW : 0) |
+           (excepts & FE_INEXACT ? INEXACT : 0);
   }
 
   static inline int exceptionStatusToMacro(uint32_t status) {
-    return (status & Invalid ? FE_INVALID : 0) |
-           (status & DivByZero ? FE_DIVBYZERO : 0) |
-           (status & Overflow ? FE_OVERFLOW : 0) |
-           (status & Underflow ? FE_UNDERFLOW : 0) |
-           (status & Inexact ? FE_INEXACT : 0);
+    return (status & INVALID ? FE_INVALID : 0) |
+           (status & DIVBYZERO ? FE_DIVBYZERO : 0) |
+           (status & OVERFLOW ? FE_OVERFLOW : 0) |
+           (status & UNDERFLOW ? FE_UNDERFLOW : 0) |
+           (status & INEXACT ? FE_INEXACT : 0);
   }
 
   static uint32_t getControlWord() { return __arm_rsr("fpcr"); }
 
   static void writeControlWord(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
 
   static uint32_t getStatusWord() { return __arm_rsr("fpsr"); }
 
__asm__ __volatile__("ldr  s0, %0\n\t"
                          "fdiv s0, s0, s1\n\t"
                          : // No outputs
                          : "m"(a), "m"(b)
                          : "s0", "s1" /* s0 and s1 are clobbered */);
   };
 
   uint32_t toRaise = FEnv::getStatusValueForExcept(excepts);
 
-  if (toRaise & FEnv::Invalid) {
+  if (toRaise & FEnv::INVALID) {
     divfunc(zero, zero);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
-          FEnv::Invalid))
+          FEnv::INVALID))
       return -1;
   }
 
-  if (toRaise & FEnv::DivByZero) {
+  if (toRaise & FEnv::DIVBYZERO) {
     divfunc(one, zero);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
-          FEnv::DivByZero))
+          FEnv::DIVBYZERO))
       return -1;
   }
-  if (toRaise & FEnv::Overflow) {
+  if (toRaise & FEnv::OVERFLOW) {
     divfunc(largeValue, smallValue);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
-          FEnv::Overflow))
+          FEnv::OVERFLOW))
       return -1;
   }
-  if (toRaise & FEnv::Underflow) {
+  if (toRaise & FEnv::UNDERFLOW) {
     divfunc(smallValue, largeValue);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
-          FEnv::Underflow))
+          FEnv::UNDERFLOW))
       return -1;
   }
-  if (toRaise & FEnv::Inexact) {
+  if (toRaise & FEnv::INEXACT) {
     float two = 2.0f;
     float three = 3.0f;
     // 2.0 / 3.0 cannot be represented exactly in any radix 2 floating point
     // format.
     divfunc(two, three);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
-          FEnv::Inexact))
+          FEnv::INEXACT))
       return -1;
   }
   return 0;
 }
 
 static inline int get_round() {
   uint32_t roundingMode =
       (FEnv::getControlWord() >> FEnv::RoundingControlBitPosition) & 0x3;
   switch (roundingMode) {
-  case FEnv::ToNearest:
+  case FEnv::TONEAREST:
     return FE_TONEAREST;
-  case FEnv::Downward:
+  case FEnv::DOWNWARD:
     return FE_DOWNWARD;
-  case FEnv::Upward:
+  case FEnv::UPWARD:
     return FE_UPWARD;
-  case FEnv::TowardZero:
+  case FEnv::TOWARDZERO:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
 static inline int set_round(int mode) {
   uint16_t bitValue;
   switch (mode) {
   case FE_TONEAREST:
-    bitValue = FEnv::ToNearest;
+    bitValue = FEnv::TONEAREST;
     break;
   case FE_DOWNWARD:
-    bitValue = FEnv::Downward;
+    bitValue = FEnv::DOWNWARD;
     break;
   case FE_UPWARD:
-    bitValue = FEnv::Upward;
+    bitValue = FEnv::UPWARD;
     break;
   case FE_TOWARDZERO:
-    bitValue = FEnv::TowardZero;
+    bitValue = FEnv::TOWARDZERO;
     break;
   default:
     return 1; // To indicate failure
   }
 
   uint32_t controlWord = FEnv::getControlWord();
   controlWord &= ~(0x3 << FEnv::RoundingControlBitPosition);
   controlWord |= (bitValue << FEnv::RoundingControlBitPosition);

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)) {
+  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/math_utils.h

 static inline uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; }
 
 static inline uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; }
 
 // Values to trigger underflow and overflow.
 template <typename T> struct XFlowValues;
 
 template <> struct XFlowValues<float> {
-  static const float overflow_value;
-  static const float underflow_value;
-  static const float may_underflow_value;
+  static const float OVERFLOW_VALUE;
+  static const float UNDERFLOW_VALUE;
+  static const float MAY_UNDERFLOW_VALUE;
 };
 
 template <> struct XFlowValues<double> {
-  static const double overflow_value;
-  static const double underflow_value;
-  static const double may_underflow_value;
+  static const double OVERFLOW_VALUE;
+  static const double UNDERFLOW_VALUE;
+  static const double MAY_UNDERFLOW_VALUE;
 };
 
 template <typename T> static inline T with_errno(T x, int err) {
   if (math_errhandling & MATH_ERRNO)
     errno = err;
   return x;
 }
 

 T xflow(uint32_t sign, T y) {
   // Underflow happens when two extremely small values are multiplied.
   // Likewise, overflow happens when two large values are multiplied.
   y = opt_barrier(sign ? -y : y) * y;
   return with_errno(y, ERANGE);
 }
 
 template <typename T, EnableIfFloatOrDouble<T> = 0> T overflow(uint32_t sign) {
-  return xflow(sign, XFlowValues<T>::overflow_value);
+  return xflow(sign, XFlowValues<T>::OVERFLOW_VALUE);
 }
 
 template <typename T, EnableIfFloatOrDouble<T> = 0> T underflow(uint32_t sign) {
-  return xflow(sign, XFlowValues<T>::underflow_value);
+  return xflow(sign, XFlowValues<T>::UNDERFLOW_VALUE);
 }
 
 template <typename T, EnableIfFloatOrDouble<T> = 0>
 T may_underflow(uint32_t sign) {
-  return xflow(sign, XFlowValues<T>::may_underflow_value);
+  return xflow(sign, XFlowValues<T>::MAY_UNDERFLOW_VALUE);
 }
 
 template <typename T, EnableIfFloatOrDouble<T> = 0>
 static inline constexpr float invalid(T x) {
   T y = (x - x) / (x - x);
   return isnan(x) ? y : with_errno(y, EDOM);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_MATH_UTILS_H

libc/src/math/generic/math_utils.cpp

 //===-- Implementation of math utils --------------------------------------===//
 //
 // 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 "math_utils.h"
 
 namespace __llvm_libc {
 
-constexpr float XFlowValues<float>::overflow_value = 0x1p97f;
-constexpr float XFlowValues<float>::underflow_value = 0x1p-95f;
-constexpr float XFlowValues<float>::may_underflow_value = 0x1.4p-75f;
+constexpr float XFlowValues<float>::OVERFLOW_VALUE = 0x1p97f;
+constexpr float XFlowValues<float>::UNDERFLOW_VALUE = 0x1p-95f;
+constexpr float XFlowValues<float>::MAY_UNDERFLOW_VALUE = 0x1.4p-75f;
 
-constexpr double XFlowValues<double>::overflow_value = 0x1p769;
-constexpr double XFlowValues<double>::underflow_value = 0x1p-767;
-constexpr double XFlowValues<double>::may_underflow_value = 0x1.8p-538;
+constexpr double XFlowValues<double>::OVERFLOW_VALUE = 0x1p769;
+constexpr double XFlowValues<double>::UNDERFLOW_VALUE = 0x1p-767;
+constexpr double XFlowValues<double>::MAY_UNDERFLOW_VALUE = 0x1.8p-538;
 
 } // 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)) {
+  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.
-constexpr sincos_t __SINCOSF_TABLE[2] = {
+constexpr sincos_t SINCOSF_TABLE[2] = {
     {{1.0, -1.0, -1.0, 1.0},
      0x1.45f306dc9c883p+23,
      0x1.921fb54442d18p+0,
      0x1p+0,
      -0x1.ffffffd0c621cp-2,
      0x1.55553e1068f19p-5,
      -0x1.6c087e89a359dp-10,
      0x1.99343027bf8c3p-16,
constexpr sincos_t SINCOSF_TABLE[2] = {
      -0x1.99343027bf8c3p-16,
      -0x1.555545995a603p-3,
      0x1.1107605230bc4p-7,
      -0x1.994eb3774cf24p-13},
 };
 
 // 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.
-constexpr uint32_t __INV_PIO4[24] = {
+constexpr 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

 
 #include "math_utils.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // 2PI * 2^-64.
-static constexpr double pi63 = 0x1.921fb54442d18p-62;
+static constexpr double PI63 = 0x1.921fb54442d18p-62;
 // PI / 4.
-static constexpr double pio4 = 0x1.921fb54442d18p-1;
+static constexpr double PIO4 = 0x1.921fb54442d18p-1;
 
 // The constants and polynomials for sine and cosine.
 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];
   res2 = (uint64_t)xi * arr[8];
   res0 = (res2 >> 32) | (res0 << 32);
   res0 += res1;
 
   n = (res0 + (1ULL << 61)) >> 62;
   res0 -= n << 62;
   double x = (int64_t)res0;
   *np = n;
-  return x * pi63;
+  return x * PI63;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H

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)) {
+  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