yggdrasil/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[libc] fix readability-identifier-naming.ConstexprFunctionCase (#83345)

Browse Source 
Codify that we use lower_case for
readability-identifier-naming.ConstexprFunctionCase and then fix the 11
violations (rather than codify UPPER_CASE and have to fix the 170 violations).
This commit is contained in:
Nick Desaulniers 2024-02-28 14:52:02 -08:00 committed by GitHub
parent fc8d481063
commit 6f8d826b74
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 87 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libc/.clang-tidy
View File

@ -26,5 +26,7 @@ CheckOptions:
value: UPPER_CASE
- key: readability-identifier-naming.ConstexprVariableCase
value: UPPER_CASE
- key: readability-identifier-naming.ConstexprFunctionCase
value: lower_case
- key: readability-identifier-naming.GetConfigPerFile
value: true

112
libc/src/__support/FPUtil/FPBits.h
View File

@ -239,23 +239,23 @@ protected:
// An opaque type to store a floating point exponent.
// We define special values but it is valid to create arbitrary values as long
// as they are in the range [MIN, MAX].
// as they are in the range [min, max].
struct Exponent : public TypedInt<int32_t> {
using UP = TypedInt<int32_t>;
using UP::UP;
LIBC_INLINE static constexpr auto SUBNORMAL() {
LIBC_INLINE static constexpr auto subnormal() {
return Exponent(-EXP_BIAS);
}
LIBC_INLINE static constexpr auto MIN() { return Exponent(1 - EXP_BIAS); }
LIBC_INLINE static constexpr auto ZERO() { return Exponent(0); }
LIBC_INLINE static constexpr auto MAX() { return Exponent(EXP_BIAS); }
LIBC_INLINE static constexpr auto INF() { return Exponent(EXP_BIAS + 1); }
LIBC_INLINE static constexpr auto min() { return Exponent(1 - EXP_BIAS); }
LIBC_INLINE static constexpr auto zero() { return Exponent(0); }
LIBC_INLINE static constexpr auto max() { return Exponent(EXP_BIAS); }
LIBC_INLINE static constexpr auto inf() { return Exponent(EXP_BIAS + 1); }
};
// An opaque type to store a floating point biased exponent.
// We define special values but it is valid to create arbitrary values as long
// as they are in the range [BITS_ALL_ZEROES, BITS_ALL_ONES].
// Values greater than BITS_ALL_ONES are truncated.
// as they are in the range [zero, bits_all_ones].
// Values greater than bits_all_ones are truncated.
struct BiasedExponent : public TypedInt<uint32_t> {
using UP = TypedInt<uint32_t>;
using UP::UP;
@ -269,13 +269,13 @@ protected:
}
LIBC_INLINE constexpr BiasedExponent &operator++() {
LIBC_ASSERT(*this != BiasedExponent(Exponent::INF()));
LIBC_ASSERT(*this != BiasedExponent(Exponent::inf()));
++UP::value;
return *this;
}
LIBC_INLINE constexpr BiasedExponent &operator--() {
LIBC_ASSERT(*this != BiasedExponent(Exponent::SUBNORMAL()));
LIBC_ASSERT(*this != BiasedExponent(Exponent::subnormal()));
--UP::value;
return *this;
}
@ -283,9 +283,9 @@ protected:
// An opaque type to store a floating point significand.
// We define special values but it is valid to create arbitrary values as long
// as they are in the range [ZERO, BITS_ALL_ONES].
// as they are in the range [zero, bits_all_ones].
// Note that the semantics of the Significand are implementation dependent.
// Values greater than BITS_ALL_ONES are truncated.
// Values greater than bits_all_ones are truncated.
struct Significand : public TypedInt<StorageType> {
using UP = TypedInt<StorageType>;
using UP::UP;
@ -305,16 +305,16 @@ protected:
return Significand(StorageType(a.to_storage_type() >> shift));
}
LIBC_INLINE static constexpr auto ZERO() {
LIBC_INLINE static constexpr auto zero() {
return Significand(StorageType(0));
}
LIBC_INLINE static constexpr auto LSB() {
LIBC_INLINE static constexpr auto lsb() {
return Significand(StorageType(1));
}
LIBC_INLINE static constexpr auto MSB() {
LIBC_INLINE static constexpr auto msb() {
return Significand(StorageType(1) << (SIG_LEN - 1));
}
LIBC_INLINE static constexpr auto BITS_ALL_ONES() {
LIBC_INLINE static constexpr auto bits_all_ones() {
return Significand(SIG_MASK);
}
};
@ -393,58 +393,58 @@ protected:
public:
// Builders
LIBC_INLINE static constexpr RetT zero(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::SUBNORMAL(), Significand::ZERO()));
return RetT(encode(sign, Exponent::subnormal(), Significand::zero()));
}
LIBC_INLINE static constexpr RetT one(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::ZERO(), Significand::ZERO()));
return RetT(encode(sign, Exponent::zero(), Significand::zero()));
}
LIBC_INLINE static constexpr RetT min_subnormal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::SUBNORMAL(), Significand::LSB()));
return RetT(encode(sign, Exponent::subnormal(), Significand::lsb()));
}
LIBC_INLINE static constexpr RetT max_subnormal(Sign sign = Sign::POS) {
return RetT(
encode(sign, Exponent::SUBNORMAL(), Significand::BITS_ALL_ONES()));
encode(sign, Exponent::subnormal(), Significand::bits_all_ones()));
}
LIBC_INLINE static constexpr RetT min_normal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::MIN(), Significand::ZERO()));
return RetT(encode(sign, Exponent::min(), Significand::zero()));
}
LIBC_INLINE static constexpr RetT max_normal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::MAX(), Significand::BITS_ALL_ONES()));
return RetT(encode(sign, Exponent::max(), Significand::bits_all_ones()));
}
LIBC_INLINE static constexpr RetT inf(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::INF(), Significand::ZERO()));
return RetT(encode(sign, Exponent::inf(), Significand::zero()));
}
LIBC_INLINE static constexpr RetT signaling_nan(Sign sign = Sign::POS,
StorageType v = 0) {
return RetT(encode(sign, Exponent::INF(),
(v ? Significand(v) : (Significand::MSB() >> 1))));
return RetT(encode(sign, Exponent::inf(),
(v ? Significand(v) : (Significand::msb() >> 1))));
}
LIBC_INLINE static constexpr RetT quiet_nan(Sign sign = Sign::POS,
StorageType v = 0) {
return RetT(
encode(sign, Exponent::INF(), Significand::MSB() | Significand(v)));
encode(sign, Exponent::inf(), Significand::msb() | Significand(v)));
}
// Observers
LIBC_INLINE constexpr bool is_zero() const { return exp_sig_bits() == 0; }
LIBC_INLINE constexpr bool is_nan() const {
return exp_sig_bits() > encode(Exponent::INF(), Significand::ZERO());
return exp_sig_bits() > encode(Exponent::inf(), Significand::zero());
}
LIBC_INLINE constexpr bool is_quiet_nan() const {
return exp_sig_bits() >= encode(Exponent::INF(), Significand::MSB());
return exp_sig_bits() >= encode(Exponent::inf(), Significand::msb());
}
LIBC_INLINE constexpr bool is_signaling_nan() const {
return is_nan() && !is_quiet_nan();
}
LIBC_INLINE constexpr bool is_inf() const {
return exp_sig_bits() == encode(Exponent::INF(), Significand::ZERO());
return exp_sig_bits() == encode(Exponent::inf(), Significand::zero());
}
LIBC_INLINE constexpr bool is_finite() const {
return exp_bits() != encode(Exponent::INF());
return exp_bits() != encode(Exponent::inf());
}
LIBC_INLINE
constexpr bool is_subnormal() const {
return exp_bits() == encode(Exponent::SUBNORMAL());
return exp_bits() == encode(Exponent::subnormal());
}
LIBC_INLINE constexpr bool is_normal() const {
return is_finite() && !is_subnormal();
@ -493,37 +493,37 @@ protected:
public:
// Builders
LIBC_INLINE static constexpr RetT zero(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::SUBNORMAL(), Significand::ZERO()));
return RetT(encode(sign, Exponent::subnormal(), Significand::zero()));
}
LIBC_INLINE static constexpr RetT one(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::ZERO(), Significand::MSB()));
return RetT(encode(sign, Exponent::zero(), Significand::msb()));
}
LIBC_INLINE static constexpr RetT min_subnormal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::SUBNORMAL(), Significand::LSB()));
return RetT(encode(sign, Exponent::subnormal(), Significand::lsb()));
}
LIBC_INLINE static constexpr RetT max_subnormal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::SUBNORMAL(),
Significand::BITS_ALL_ONES() ^ Significand::MSB()));
return RetT(encode(sign, Exponent::subnormal(),
Significand::bits_all_ones() ^ Significand::msb()));
}
LIBC_INLINE static constexpr RetT min_normal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::MIN(), Significand::MSB()));
return RetT(encode(sign, Exponent::min(), Significand::msb()));
}
LIBC_INLINE static constexpr RetT max_normal(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::MAX(), Significand::BITS_ALL_ONES()));
return RetT(encode(sign, Exponent::max(), Significand::bits_all_ones()));
}
LIBC_INLINE static constexpr RetT inf(Sign sign = Sign::POS) {
return RetT(encode(sign, Exponent::INF(), Significand::MSB()));
return RetT(encode(sign, Exponent::inf(), Significand::msb()));
}
LIBC_INLINE static constexpr RetT signaling_nan(Sign sign = Sign::POS,
StorageType v = 0) {
return RetT(encode(sign, Exponent::INF(),
Significand::MSB() |
(v ? Significand(v) : (Significand::MSB() >> 2))));
return RetT(encode(sign, Exponent::inf(),
Significand::msb() |
(v ? Significand(v) : (Significand::msb() >> 2))));
}
LIBC_INLINE static constexpr RetT quiet_nan(Sign sign = Sign::POS,
StorageType v = 0) {
return RetT(encode(sign, Exponent::INF(),
Significand::MSB() | (Significand::MSB() >> 1) |
return RetT(encode(sign, Exponent::inf(),
Significand::msb() | (Significand::msb() >> 1) |
Significand(v)));
}
@ -541,33 +541,33 @@ public:
// - Quiet Not a Number
// - Unnormal
// This can be reduced to the following logic:
if (exp_bits() == encode(Exponent::INF()))
if (exp_bits() == encode(Exponent::inf()))
return !is_inf();
if (exp_bits() != encode(Exponent::SUBNORMAL()))
return (sig_bits() & encode(Significand::MSB())) == 0;
if (exp_bits() != encode(Exponent::subnormal()))
return (sig_bits() & encode(Significand::msb())) == 0;
return false;
}
LIBC_INLINE constexpr bool is_quiet_nan() const {
return exp_sig_bits() >=
encode(Exponent::INF(),
Significand::MSB() | (Significand::MSB() >> 1));
encode(Exponent::inf(),
Significand::msb() | (Significand::msb() >> 1));
}
LIBC_INLINE constexpr bool is_signaling_nan() const {
return is_nan() && !is_quiet_nan();
}
LIBC_INLINE constexpr bool is_inf() const {
return exp_sig_bits() == encode(Exponent::INF(), Significand::MSB());
return exp_sig_bits() == encode(Exponent::inf(), Significand::msb());
}
LIBC_INLINE constexpr bool is_finite() const {
return !is_inf() && !is_nan();
}
LIBC_INLINE
constexpr bool is_subnormal() const {
return exp_bits() == encode(Exponent::SUBNORMAL());
return exp_bits() == encode(Exponent::subnormal());
}
LIBC_INLINE constexpr bool is_normal() const {
const auto exp = exp_bits();
if (exp == encode(Exponent::SUBNORMAL()) || exp == encode(Exponent::INF()))
if (exp == encode(Exponent::subnormal()) || exp == encode(Exponent::inf()))
return false;
return get_implicit_bit();
}
@ -578,7 +578,7 @@ public:
} else if (exp_sig_bits() == max_subnormal().uintval()) {
return min_normal(sign());
} else if (sig_bits() == SIG_MASK) {
return RetT(encode(sign(), ++biased_exponent(), Significand::ZERO()));
return RetT(encode(sign(), ++biased_exponent(), Significand::zero()));
} else {
return RetT(bits + StorageType(1));
}
@ -715,9 +715,9 @@ public:
LIBC_INLINE constexpr int get_explicit_exponent() const {
Exponent exponent(UP::biased_exponent());
if (is_zero())
exponent = Exponent::ZERO();
if (exponent == Exponent::SUBNORMAL())
exponent = Exponent::MIN();
exponent = Exponent::zero();
if (exponent == Exponent::subnormal())
exponent = Exponent::min();
return static_cast<int32_t>(exponent);
}

2
libc/src/string/memory_utils/aarch64/inline_bcmp.h
View File

@ -27,7 +27,7 @@ namespace LIBC_NAMESPACE {
}
switch (count) {
case 0:
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
case 1:
return generic::Bcmp<uint8_t>::block(p1, p2);
case 2:

2
libc/src/string/memory_utils/aarch64/inline_memcmp.h
View File

@ -50,7 +50,7 @@ inline_memcmp_aarch64_neon_gt16(CPtr p1, CPtr p2, size_t count) {
LIBC_INLINE MemcmpReturnType inline_memcmp_aarch64(CPtr p1, CPtr p2,
size_t count) {
if (count == 0)
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
if (count == 1)
return generic::Memcmp<uint8_t>::block(p1, p2);
if (count == 2)

4
libc/src/string/memory_utils/generic/aligned_access.h
View File

@ -135,7 +135,7 @@ inline_bcmp_aligned_access_32bit(CPtr p1, CPtr p2, size_t count) {
uint32_t a = load32_aligned<uint32_t>(p1, offset);
uint32_t b = load32_aligned(p2, offset, p2_alignment);
if (a != b)
return BcmpReturnType::NONZERO();
return BcmpReturnType::nonzero();
}
return inline_bcmp_byte_per_byte(p1, p2, count, offset);
}
@ -154,7 +154,7 @@ inline_bcmp_aligned_access_64bit(CPtr p1, CPtr p2, size_t count) {
uint64_t a = load64_aligned<uint64_t>(p1, offset);
uint64_t b = load64_aligned(p2, offset, p2_alignment);
if (a != b)
return BcmpReturnType::NONZERO();
return BcmpReturnType::nonzero();
}
return inline_bcmp_byte_per_byte(p1, p2, count, offset);
}

6
libc/src/string/memory_utils/generic/byte_per_byte.h
View File

@ -56,8 +56,8 @@ inline_bcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
LIBC_LOOP_NOUNROLL
for (; offset < count; ++offset)
if (p1[offset] != p2[offset])
return BcmpReturnType::NONZERO();
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
return BcmpReturnType::zero();
}
[[maybe_unused]] LIBC_INLINE MemcmpReturnType
@ -70,7 +70,7 @@ inline_memcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
if (diff)
return diff;
}
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
} // namespace LIBC_NAMESPACE

10
libc/src/string/memory_utils/op_aarch64.h
View File

@ -108,7 +108,7 @@ template <size_t Size> struct Bcmp {
} else {
static_assert(cpp::always_false<decltype(Size)>, "SIZE not implemented");
}
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
LIBC_INLINE static BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
@ -154,7 +154,7 @@ template <size_t Size> struct Bcmp {
} else {
static_assert(cpp::always_false<decltype(Size)>, "SIZE not implemented");
}
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
LIBC_INLINE static BcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
@ -217,7 +217,7 @@ LIBC_INLINE MemcmpReturnType cmp<uint64_t>(CPtr p1, CPtr p2, size_t offset) {
const auto b = load_be<uint64_t>(p2, offset);
if (a != b)
return a > b ? 1 : -1;
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
///////////////////////////////////////////////////////////////////////////////
@ -245,7 +245,7 @@ LIBC_INLINE MemcmpReturnType cmp<uint8x16_t>(CPtr p1, CPtr p2, size_t offset) {
return cmp_neq_uint64_t(a, b);
offset += sizeof(uint64_t);
}
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
///////////////////////////////////////////////////////////////////////////////
@ -262,7 +262,7 @@ LIBC_INLINE MemcmpReturnType cmp<uint8x16x2_t>(CPtr p1, CPtr p2,
return cmp_neq_uint64_t(a, b);
offset += sizeof(uint64_t);
}
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
} // namespace LIBC_NAMESPACE::generic

16
libc/src/string/memory_utils/op_builtin.h
View File

@ -105,22 +105,22 @@ template <size_t Size> struct Bcmp {
LIBC_INLINE static BcmpReturnType block(CPtr, CPtr) {
static_assert(cpp::always_false<decltype(Size)>,
"Missing __builtin_memcmp_inline");
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
LIBC_INLINE static BcmpReturnType tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
LIBC_INLINE static BcmpReturnType head_tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
LIBC_INLINE static BcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
};
@ -132,22 +132,22 @@ template <size_t Size> struct Memcmp {
LIBC_INLINE static MemcmpReturnType block(CPtr, CPtr) {
static_assert(cpp::always_false<decltype(Size)>,
"Missing __builtin_memcmp_inline");
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
LIBC_INLINE static MemcmpReturnType tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
LIBC_INLINE static MemcmpReturnType head_tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
LIBC_INLINE static MemcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
static_assert(cpp::always_false<decltype(Size)>, "Not implemented");
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
};

10
libc/src/string/memory_utils/op_generic.h
View File

@ -390,7 +390,7 @@ private:
if constexpr (cmp_is_expensive<T>::value) {
if (!eq<T>(p1, p2, offset))
return cmp_neq<T>(p1, p2, offset);
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
} else {
return cmp<T>(p1, p2, offset);
}
@ -443,7 +443,7 @@ public:
for (; offset < count; offset += SIZE)
if (auto value = cmp<T>(p1, p2, offset))
return value;
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
}
@ -475,7 +475,7 @@ template <typename T, typename... TS> struct MemcmpSequence {
if constexpr (sizeof...(TS) > 0)
return MemcmpSequence<TS...>::block(p1 + sizeof(T), p2 + sizeof(T));
else
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
}
};
@ -521,7 +521,7 @@ template <typename T> struct Bcmp {
for (; offset < count; offset += SIZE)
if (const auto value = neq<T>(p1, p2, offset))
return value;
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
}
@ -547,7 +547,7 @@ template <typename T, typename... TS> struct BcmpSequence {
if constexpr (sizeof...(TS) > 0)
return BcmpSequence<TS...>::block(p1 + sizeof(T), p2 + sizeof(T));
else
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
}
};

4
libc/src/string/memory_utils/utils.h
View File

@ -130,8 +130,8 @@ template <typename T> struct StrictIntegralType {
}
// Helper to get the zero value.
LIBC_INLINE static constexpr StrictIntegralType ZERO() { return {T(0)}; }
LIBC_INLINE static constexpr StrictIntegralType NONZERO() { return {T(1)}; }
LIBC_INLINE static constexpr StrictIntegralType zero() { return {T(0)}; }
LIBC_INLINE static constexpr StrictIntegralType nonzero() { return {T(1)}; }
private:
T value;

2
libc/src/string/memory_utils/x86_64/inline_bcmp.h
View File

@ -58,7 +58,7 @@ inline_bcmp_x86_avx512bw_gt16(CPtr p1, CPtr p2, size_t count) {
[[maybe_unused]] LIBC_INLINE BcmpReturnType inline_bcmp_x86(CPtr p1, CPtr p2,
size_t count) {
if (count == 0)
return BcmpReturnType::ZERO();
return BcmpReturnType::zero();
if (count == 1)
return generic::Bcmp<uint8_t>::block(p1, p2);
if (count == 2)

2
libc/src/string/memory_utils/x86_64/inline_memcmp.h
View File

@ -59,7 +59,7 @@ inline_memcmp_x86_avx512bw_gt16(CPtr p1, CPtr p2, size_t count) {
LIBC_INLINE MemcmpReturnType inline_memcmp_x86(CPtr p1, CPtr p2, size_t count) {
if (count == 0)
return MemcmpReturnType::ZERO();
return MemcmpReturnType::zero();
if (count == 1)
return generic::Memcmp<uint8_t>::block(p1, p2);
if (count == 2)