Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Feb 28, 2024
Merged

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
28ba499
[libc] fix readability-identifier-naming.ConstexprFunctionCase
nickdesaulniers Feb 28, 2024
cf79282
fix up comment
nickdesaulniers Feb 28, 2024
dc0ad00
fix up non x86
nickdesaulniers Feb 28, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions libc/.clang-tidy
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 changes: 56 additions & 56 deletions libc/src/__support/FPUtil/FPBits.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -239,23 +239,23 @@ template <FPType fp_type> struct FPStorage : public FPLayout<fp_type> {

// 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;
Expand All @@ -269,23 +269,23 @@ template <FPType fp_type> struct FPStorage : public FPLayout<fp_type> {
}

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;
}
};

// 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;
Expand All @@ -305,16 +305,16 @@ template <FPType fp_type> struct FPStorage : public FPLayout<fp_type> {
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);
}
};
Expand Down Expand Up @@ -393,58 +393,58 @@ struct FPRepSem : public FPStorage<fp_type> {
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();
Expand Down Expand Up @@ -493,37 +493,37 @@ struct FPRepSem<FPType::X86_Binary80, RetT>
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)));
}

Expand All @@ -541,33 +541,33 @@ struct FPRepSem<FPType::X86_Binary80, RetT>
// - 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();
}
Expand All @@ -578,7 +578,7 @@ struct FPRepSem<FPType::X86_Binary80, RetT>
} 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));
}
Expand Down Expand Up @@ -715,9 +715,9 @@ struct FPRepImpl : public FPRepSem<fp_type, RetT> {
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);
}

Expand Down
2 changes: 1 addition & 1 deletion libc/src/string/memory_utils/aarch64/inline_bcmp.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand Down
2 changes: 1 addition & 1 deletion libc/src/string/memory_utils/aarch64/inline_memcmp.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
4 changes: 2 additions & 2 deletions libc/src/string/memory_utils/generic/aligned_access.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand All @@ -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);
}
Expand Down
6 changes: 3 additions & 3 deletions libc/src/string/memory_utils/generic/byte_per_byte.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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();
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

oops!
#83356

return BcmpReturnType::zero();
}

[[maybe_unused]] LIBC_INLINE MemcmpReturnType
Expand All @@ -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
Expand Down
10 changes: 5 additions & 5 deletions libc/src/string/memory_utils/op_aarch64.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down Expand Up @@ -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,
Expand Down Expand Up @@ -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();
}

///////////////////////////////////////////////////////////////////////////////
Expand Down Expand Up @@ -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();
}

///////////////////////////////////////////////////////////////////////////////
Expand All @@ -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

Expand Down
Loading