[libc-commits] [libc] 1c92911 - [libc] apply new lint rules
Michael Jones via libc-commits
libc-commits at lists.llvm.org
Tue Dec 7 10:49:59 PST 2021
Author: Michael Jones
Date: 2021-12-07T10:49:47-08:00
New Revision: 1c92911e9e1d503c0dfc4367da7f15d0dff50587
URL: https://github.com/llvm/llvm-project/commit/1c92911e9e1d503c0dfc4367da7f15d0dff50587
DIFF: https://github.com/llvm/llvm-project/commit/1c92911e9e1d503c0dfc4367da7f15d0dff50587.diff
LOG: [libc] apply new lint rules
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.
Reviewed By: sivachandra, lntue
Differential Revision: https://reviews.llvm.org/D114302
Added:
Modified:
libc/benchmarks/automemcpy/lib/CodeGen.cpp
libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp
libc/fuzzing/math/Compare.h
libc/src/__support/CPP/Bitset.h
libc/src/__support/FPUtil/BasicOperations.h
libc/src/__support/FPUtil/DivisionAndRemainderOperations.h
libc/src/__support/FPUtil/FEnvImpl.h
libc/src/__support/FPUtil/FPBits.h
libc/src/__support/FPUtil/FloatProperties.h
libc/src/__support/FPUtil/Hypot.h
libc/src/__support/FPUtil/ManipulationFunctions.h
libc/src/__support/FPUtil/NearestIntegerOperations.h
libc/src/__support/FPUtil/NormalFloat.h
libc/src/__support/FPUtil/Sqrt.h
libc/src/__support/FPUtil/aarch64/FEnvImpl.h
libc/src/__support/FPUtil/generic/FMA.h
libc/src/__support/FPUtil/x86_64/FEnvImpl.h
libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h
libc/src/__support/detailed_powers_of_ten.h
libc/src/__support/endian.h
libc/src/__support/high_precision_decimal.h
libc/src/__support/integer_operations.h
libc/src/__support/str_to_float.h
libc/src/__support/str_to_integer.h
libc/src/assert/__assert_fail.cpp
libc/src/errno/__errno_location.cpp
libc/src/fenv/feclearexcept.cpp
libc/src/fenv/fedisableexcept.cpp
libc/src/fenv/feenableexcept.cpp
libc/src/fenv/fegetenv.cpp
libc/src/fenv/fegetexcept.cpp
libc/src/fenv/fegetexceptflag.cpp
libc/src/fenv/fegetround.cpp
libc/src/fenv/feholdexcept.cpp
libc/src/fenv/feraiseexcept.cpp
libc/src/fenv/fesetenv.cpp
libc/src/fenv/fesetexceptflag.cpp
libc/src/fenv/fesetround.cpp
libc/src/fenv/fetestexcept.cpp
libc/src/fenv/feupdateenv.cpp
libc/src/inttypes/imaxdiv.cpp
libc/src/math/generic/cosf.cpp
libc/src/math/generic/dp_trig.cpp
libc/src/math/generic/expm1f.cpp
libc/src/math/generic/llrint.cpp
libc/src/math/generic/llrintf.cpp
libc/src/math/generic/llrintl.cpp
libc/src/math/generic/llround.cpp
libc/src/math/generic/llroundf.cpp
libc/src/math/generic/llroundl.cpp
libc/src/math/generic/lrint.cpp
libc/src/math/generic/lrintf.cpp
libc/src/math/generic/lrintl.cpp
libc/src/math/generic/lround.cpp
libc/src/math/generic/lroundf.cpp
libc/src/math/generic/lroundl.cpp
libc/src/math/generic/math_utils.h
libc/src/math/generic/nearbyint.cpp
libc/src/math/generic/nearbyintf.cpp
libc/src/math/generic/nearbyintl.cpp
libc/src/math/generic/rint.cpp
libc/src/math/generic/rintf.cpp
libc/src/math/generic/rintl.cpp
libc/src/math/generic/sincosf.cpp
libc/src/math/generic/sincosf_data.cpp
libc/src/math/generic/sincosf_utils.h
libc/src/math/generic/sinf.cpp
libc/src/signal/linux/sigaction.cpp
libc/src/signal/linux/sigemptyset.cpp
libc/src/signal/linux/signal.h
libc/src/stdlib/abs.cpp
libc/src/stdlib/div.cpp
libc/src/stdlib/labs.cpp
libc/src/stdlib/ldiv.cpp
libc/src/stdlib/llabs.cpp
libc/src/stdlib/lldiv.cpp
libc/src/string/memccpy.cpp
libc/src/string/memmove.cpp
libc/src/string/memory_utils/bcmp_implementations.h
libc/src/string/memory_utils/elements.h
libc/src/string/memory_utils/elements_aarch64.h
libc/src/string/memory_utils/elements_x86.h
libc/src/string/memory_utils/memcmp_implementations.h
libc/src/string/memory_utils/memcpy_implementations.h
libc/src/string/memory_utils/memset_implementations.h
libc/src/string/strcat.cpp
libc/src/string/strncat.cpp
libc/src/threads/linux/Thread.h
libc/src/threads/linux/thrd_create.cpp
libc/src/threads/linux/thrd_join.cpp
libc/src/time/asctime.cpp
libc/src/time/asctime_r.cpp
libc/src/time/mktime.cpp
libc/src/time/time_utils.cpp
libc/src/time/time_utils.h
libc/test/src/__support/endian_test.cpp
libc/test/src/__support/high_precision_decimal_test.cpp
libc/test/src/__support/str_to_float_test.cpp
libc/test/src/fenv/enabled_exceptions_test.cpp
libc/test/src/fenv/exception_flags_test.cpp
libc/test/src/fenv/exception_status_test.cpp
libc/test/src/fenv/feclearexcept_test.cpp
libc/test/src/fenv/feholdexcept_test.cpp
libc/test/src/fenv/feupdateenv_test.cpp
libc/test/src/fenv/getenv_and_setenv_test.cpp
libc/test/src/math/CeilTest.h
libc/test/src/math/CopySignTest.h
libc/test/src/math/FAbsTest.h
libc/test/src/math/FDimTest.h
libc/test/src/math/FMaxTest.h
libc/test/src/math/FMinTest.h
libc/test/src/math/FloorTest.h
libc/test/src/math/FmaTest.h
libc/test/src/math/FrexpTest.h
libc/test/src/math/HypotTest.h
libc/test/src/math/ILogbTest.h
libc/test/src/math/LdExpTest.h
libc/test/src/math/LogbTest.h
libc/test/src/math/ModfTest.h
libc/test/src/math/NextAfterTest.h
libc/test/src/math/RIntTest.h
libc/test/src/math/RemQuoTest.h
libc/test/src/math/RoundTest.h
libc/test/src/math/RoundToIntegerTest.h
libc/test/src/math/SqrtTest.h
libc/test/src/math/TruncTest.h
libc/test/src/math/cosf_test.cpp
libc/test/src/math/exhaustive/expm1f_test.cpp
libc/test/src/math/exp2f_test.cpp
libc/test/src/math/expf_test.cpp
libc/test/src/math/expm1f_test.cpp
libc/test/src/math/sincosf_test.cpp
libc/test/src/math/sinf_test.cpp
libc/test/src/stdlib/atof_test.cpp
libc/test/src/stdlib/strtod_test.cpp
libc/test/src/stdlib/strtof_test.cpp
libc/test/src/string/memory_utils/elements_test.cpp
libc/test/src/string/memory_utils/memory_access_test.cpp
libc/test/src/time/TmHelper.h
libc/test/src/time/asctime_r_test.cpp
libc/test/src/time/gmtime_r_test.cpp
libc/test/src/time/gmtime_test.cpp
libc/test/src/time/mktime_test.cpp
libc/test/utils/FPUtil/x86_long_double_test.cpp
libc/utils/MPFRWrapper/MPFRUtils.cpp
libc/utils/UnitTest/FPMatcher.cpp
libc/utils/UnitTest/FPMatcher.h
Removed:
################################################################################
diff --git a/libc/benchmarks/automemcpy/lib/CodeGen.cpp b/libc/benchmarks/automemcpy/lib/CodeGen.cpp
index f294a58efc8f0..c150ab554b46f 100644
--- a/libc/benchmarks/automemcpy/lib/CodeGen.cpp
+++ b/libc/benchmarks/automemcpy/lib/CodeGen.cpp
@@ -64,12 +64,12 @@ namespace functions {
// 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
@@ -114,7 +114,7 @@ struct Accelerator {
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;
@@ -140,7 +140,7 @@ static Context getCtx(FunctionType 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",
@@ -149,7 +149,7 @@ static Context getCtx(FunctionType FT) {
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",
@@ -158,7 +158,7 @@ static Context getCtx(FunctionType FT) {
case FunctionType::MEMSET:
return {"void",
"(char * dst, int value, size_t size)",
- "SplatSet",
+ "splat_set",
"(dst, value)",
"(dst, value, size)",
"Arg::Dst",
@@ -166,7 +166,7 @@ static Context getCtx(FunctionType FT) {
""};
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:
diff --git a/libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp b/libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp
index 6849682c44459..d87b27b2002b6 100644
--- a/libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp
+++ b/libc/benchmarks/automemcpy/unittests/CodeGenTest.cpp
@@ -65,71 +65,71 @@ 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
diff --git a/libc/fuzzing/math/Compare.h b/libc/fuzzing/math/Compare.h
index 8a794c4cabbcc..693f572a189d4 100644
--- a/libc/fuzzing/math/Compare.h
+++ b/libc/fuzzing/math/Compare.h
@@ -19,8 +19,8 @@ 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();
diff --git a/libc/src/__support/CPP/Bitset.h b/libc/src/__support/CPP/Bitset.h
index e6f5ace9d6857..db0569c74c389 100644
--- a/libc/src/__support/CPP/Bitset.h
+++ b/libc/src/__support/CPP/Bitset.h
@@ -20,17 +20,18 @@ template <size_t NumberOfBits> struct Bitset {
"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
diff --git a/libc/src/__support/FPUtil/BasicOperations.h b/libc/src/__support/FPUtil/BasicOperations.h
index 08d722268780e..8a66062ee1e9d 100644
--- a/libc/src/__support/FPUtil/BasicOperations.h
+++ b/libc/src/__support/FPUtil/BasicOperations.h
@@ -20,7 +20,7 @@ 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);
}
@@ -29,15 +29,15 @@ template <typename T,
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
diff erent 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);
}
@@ -48,15 +48,15 @@ template <typename T,
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
diff erent 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);
}
@@ -67,11 +67,11 @@ template <typename T,
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;
}
diff --git a/libc/src/__support/FPUtil/DivisionAndRemainderOperations.h b/libc/src/__support/FPUtil/DivisionAndRemainderOperations.h
index 412ea96aa5519..44cab316c7d2e 100644
--- a/libc/src/__support/FPUtil/DivisionAndRemainderOperations.h
+++ b/libc/src/__support/FPUtil/DivisionAndRemainderOperations.h
@@ -18,7 +18,7 @@
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.
@@ -26,30 +26,30 @@ 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;
@@ -58,21 +58,21 @@ static inline T remquo(T x, T y, int &q) {
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);
}
}
@@ -84,33 +84,33 @@ static inline T remquo(T x, T y, int &q) {
// 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
diff --git a/libc/src/__support/FPUtil/FEnvImpl.h b/libc/src/__support/FPUtil/FEnvImpl.h
index 967df4bcf1d22..8330f792e7e86 100644
--- a/libc/src/__support/FPUtil/FEnvImpl.h
+++ b/libc/src/__support/FPUtil/FEnvImpl.h
@@ -24,21 +24,21 @@ 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
diff --git a/libc/src/__support/FPUtil/FPBits.h b/libc/src/__support/FPUtil/FPBits.h
index 10a3dcd07681e..19c1d1f1ac8f6 100644
--- a/libc/src/__support/FPUtil/FPBits.h
+++ b/libc/src/__support/FPUtil/FPBits.h
@@ -20,11 +20,11 @@ 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
@@ -48,49 +48,49 @@ template <typename T> union FPBits {
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
diff erent 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.
@@ -108,43 +108,45 @@ template <typename T> union FPBits {
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);
}
};
diff --git a/libc/src/__support/FPUtil/FloatProperties.h b/libc/src/__support/FPUtil/FloatProperties.h
index d8d0fea977d24..8cf0da1267a91 100644
--- a/libc/src/__support/FPUtil/FloatProperties.h
+++ b/libc/src/__support/FPUtil/FloatProperties.h
@@ -22,20 +22,20 @@ template <> struct FloatProperties<float> {
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> {
@@ -43,20 +43,20 @@ template <> struct FloatProperties<double> {
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)
@@ -67,25 +67,25 @@ template <> struct FloatProperties<long double> {
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
@@ -95,21 +95,22 @@ template <> struct FloatProperties<long double> {
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
@@ -119,20 +120,21 @@ template <> struct FloatProperties<long double> {
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
diff --git a/libc/src/__support/FPUtil/Hypot.h b/libc/src/__support/FPUtil/Hypot.h
index aa8b720e9f40d..78a3571021a4a 100644
--- a/libc/src/__support/FPUtil/Hypot.h
+++ b/libc/src/__support/FPUtil/Hypot.h
@@ -18,34 +18,35 @@ 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;
@@ -124,13 +125,13 @@ static inline T hypot(T x, T y) {
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;
}
@@ -139,33 +140,33 @@ static inline T hypot(T x, T y) {
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;
@@ -173,16 +174,16 @@ static inline T hypot(T x, T y) {
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;
}
@@ -204,13 +205,13 @@ static inline T hypot(T x, T y) {
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 {
@@ -221,48 +222,48 @@ static inline T hypot(T x, T y) {
}
}
- 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
diff --git a/libc/src/__support/FPUtil/ManipulationFunctions.h b/libc/src/__support/FPUtil/ManipulationFunctions.h
index 3c7783ea73a4e..0c6f322e3c517 100644
--- a/libc/src/__support/FPUtil/ManipulationFunctions.h
+++ b/libc/src/__support/FPUtil/ManipulationFunctions.h
@@ -26,9 +26,9 @@ 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;
}
@@ -43,18 +43,18 @@ 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;
}
@@ -65,7 +65,7 @@ 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);
}
@@ -75,11 +75,11 @@ 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;
}
@@ -102,13 +102,13 @@ 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());
}
@@ -121,7 +121,7 @@ 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
@@ -130,13 +130,13 @@ static inline T ldexp(T x, int exp) {
// 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);
@@ -147,31 +147,31 @@ static inline T ldexp(T x, int exp) {
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.
}
diff --git a/libc/src/__support/FPUtil/NearestIntegerOperations.h b/libc/src/__support/FPUtil/NearestIntegerOperations.h
index 6862488edac8a..eb4e290218365 100644
--- a/libc/src/__support/FPUtil/NearestIntegerOperations.h
+++ b/libc/src/__support/FPUtil/NearestIntegerOperations.h
@@ -31,26 +31,26 @@ static inline T trunc(T x) {
// 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);
}
@@ -60,44 +60,44 @@ 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);
@@ -111,20 +111,20 @@ static inline T round(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) {
// 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);
@@ -132,102 +132,102 @@ static inline T round(T x) {
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();
@@ -240,33 +240,33 @@ 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.
@@ -284,17 +284,17 @@ 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
diff --git a/libc/src/__support/FPUtil/NormalFloat.h b/libc/src/__support/FPUtil/NormalFloat.h
index 2c83b81e9a4fe..939db0909d97c 100644
--- a/libc/src/__support/FPUtil/NormalFloat.h
+++ b/libc/src/__support/FPUtil/NormalFloat.h
@@ -31,7 +31,7 @@ template <typename T> struct NormalFloat {
"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;
@@ -39,24 +39,24 @@ template <typename T> struct NormalFloat {
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
@@ -89,59 +89,59 @@ template <typename T> struct NormalFloat {
}
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;
@@ -150,19 +150,19 @@ template <typename T> struct NormalFloat {
}
// 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;
@@ -171,10 +171,10 @@ template <typename T> struct NormalFloat {
#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;
@@ -182,67 +182,69 @@ inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
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 {
@@ -250,9 +252,9 @@ template <> inline NormalFloat<long double>::operator long double() const {
}
}
- 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
diff --git a/libc/src/__support/FPUtil/Sqrt.h b/libc/src/__support/FPUtil/Sqrt.h
index 093f1b3b6e4a9..246535aab8146 100644
--- a/libc/src/__support/FPUtil/Sqrt.h
+++ b/libc/src/__support/FPUtil/Sqrt.h
@@ -97,32 +97,32 @@ 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 {
@@ -170,9 +170,9 @@ static inline T sqrt(T x) {
}
// 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;
diff --git a/libc/src/__support/FPUtil/aarch64/FEnvImpl.h b/libc/src/__support/FPUtil/aarch64/FEnvImpl.h
index 129319373ea88..305ecffeecd3a 100644
--- a/libc/src/__support/FPUtil/aarch64/FEnvImpl.h
+++ b/libc/src/__support/FPUtil/aarch64/FEnvImpl.h
@@ -75,7 +75,7 @@ struct FEnv {
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 =
@@ -85,7 +85,7 @@ static inline int enableExcept(int excepts) {
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 =
@@ -95,14 +95,14 @@ static inline int disableExcept(int excepts) {
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);
@@ -110,14 +110,14 @@ static inline int clearExcept(int excepts) {
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);
@@ -125,11 +125,11 @@ static inline int setExcept(int excepts) {
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"
@@ -184,7 +184,7 @@ static inline int raiseExcept(int excepts) {
return 0;
}
-static inline int getRound() {
+static inline int get_round() {
uint32_t roundingMode =
(FEnv::getControlWord() >> FEnv::RoundingControlBitPosition) & 0x3;
switch (roundingMode) {
@@ -201,7 +201,7 @@ static inline int getRound() {
}
}
-static inline int setRound(int mode) {
+static inline int set_round(int mode) {
uint16_t bitValue;
switch (mode) {
case FE_TONEAREST:
@@ -228,14 +228,14 @@ static inline int setRound(int mode) {
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.
diff --git a/libc/src/__support/FPUtil/generic/FMA.h b/libc/src/__support/FPUtil/generic/FMA.h
index c543a490a94bc..efdd8b7129753 100644
--- a/libc/src/__support/FPUtil/generic/FMA.h
+++ b/libc/src/__support/FPUtil/generic/FMA.h
@@ -24,7 +24,7 @@ static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
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
@@ -47,17 +47,17 @@ static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
// 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);
}
}
}
diff --git a/libc/src/__support/FPUtil/x86_64/FEnvImpl.h b/libc/src/__support/FPUtil/x86_64/FEnvImpl.h
index 8e2336c011544..731c617b52b09 100644
--- a/libc/src/__support/FPUtil/x86_64/FEnvImpl.h
+++ b/libc/src/__support/FPUtil/x86_64/FEnvImpl.h
@@ -36,109 +36,109 @@ namespace internal {
// register have the same 2-bit enoding but have
diff erent 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) :);
}
@@ -146,96 +146,96 @@ 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);
+ 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::getMXCSR();
- mxcsr &= ~internal::getStatusValueForExcept(excepts);
- internal::writeMXCSR(mxcsr);
+ 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);
+ internal::get_x87_state_descriptor(state);
+ state.status_word |= status_value;
+ internal::write_x87_state_descriptor(state);
- uint32_t mxcsr = internal::getMXCSR();
- mxcsr |= statusValue;
- internal::writeMXCSR(mxcsr);
+ 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
@@ -250,24 +250,24 @@ static inline int raiseExcept(int excepts) {
// 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);
@@ -282,57 +282,59 @@ static inline int raiseExcept(int excepts) {
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;
}
@@ -348,8 +350,8 @@ struct FPState {
};
#else
struct FPState {
- X87StateDescriptor X87Status;
- uint32_t MXCSR;
+ X87StateDescriptor x87_status;
+ uint32_t mxcsr;
};
#endif // _WIN32
@@ -360,7 +362,7 @@ static_assert(
"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);
@@ -369,7 +371,7 @@ static inline int getEnv(fenv_t *envp) {
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;
@@ -379,47 +381,47 @@ static inline int setEnv(const fenv_t *envp) {
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;
}
@@ -428,17 +430,17 @@ static inline int setEnv(const fenv_t *envp) {
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
diff --git a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
index 43a3d415e81ef..4fc00b1429779 100644
--- a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
+++ b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
@@ -25,68 +25,70 @@ 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;
@@ -109,73 +111,73 @@ template <> union FPBits<long double> {
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;
}
};
diff --git a/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h b/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
index a6e9461be9516..db5c946a4d830 100644
--- a/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
+++ b/libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h
@@ -24,93 +24,94 @@ 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.
}
diff --git a/libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h b/libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h
index 4c0e2f1c694e5..0f8393f02a8cf 100644
--- a/libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h
+++ b/libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h
@@ -50,34 +50,34 @@ inline void normalize<long double>(int &exponent, __uint128_t &mantissa) {
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);
}
@@ -122,9 +122,9 @@ template <> inline long double sqrt<long double, 0>(long double x) {
}
// 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))) {
@@ -133,9 +133,9 @@ template <> inline long double sqrt<long double, 0>(long double x) {
// 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;
}
diff --git a/libc/src/__support/detailed_powers_of_ten.h b/libc/src/__support/detailed_powers_of_ten.h
index 9a58ba5dff782..80dfcb2d6a59e 100644
--- a/libc/src/__support/detailed_powers_of_ten.h
+++ b/libc/src/__support/detailed_powers_of_ten.h
@@ -27,11 +27,11 @@ 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
diff --git a/libc/src/__support/endian.h b/libc/src/__support/endian.h
index 5f977aa466c5b..8108d56c2d07b 100644
--- a/libc/src/__support/endian.h
+++ b/libc/src/__support/endian.h
@@ -28,108 +28,108 @@ namespace internal {
// - 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);
}
diff --git a/libc/src/__support/high_precision_decimal.h b/libc/src/__support/high_precision_decimal.h
index 352de581a8f72..00ccd7078c198 100644
--- a/libc/src/__support/high_precision_decimal.h
+++ b/libc/src/__support/high_precision_decimal.h
@@ -17,8 +17,8 @@ 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
@@ -105,20 +105,20 @@ class HighPrecisionDecimal {
// 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.)
@@ -136,99 +136,101 @@ class HighPrecisionDecimal {
// 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;
+ 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[digitIndex] != powerOfFive[digitIndex] - '0') {
- return newDigits -
- ((this->digits[digitIndex] < powerOfFive[digitIndex] - '0') ? 1
- : 0);
+ 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
+ : 0);
}
- ++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;
@@ -237,64 +239,64 @@ class HighPrecisionDecimal {
// 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;
}
@@ -302,24 +304,24 @@ class HighPrecisionDecimal {
++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)
@@ -330,39 +332,39 @@ class HighPrecisionDecimal {
// 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;
@@ -370,10 +372,10 @@ class HighPrecisionDecimal {
// 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
diff --git a/libc/src/__support/integer_operations.h b/libc/src/__support/integer_operations.h
index e7588f5ef2cc9..ffb4ec5c1091a 100644
--- a/libc/src/__support/integer_operations.h
+++ b/libc/src/__support/integer_operations.h
@@ -15,13 +15,13 @@ 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 ", T &rem) {
+integer_rem_quo(T x, T y, T ", T &rem) {
quot = x / y;
rem = x % y;
}
diff --git a/libc/src/__support/str_to_float.h b/libc/src/__support/str_to_float.h
index 7673334cefabf..16b5cd3beee9f 100644
--- a/libc/src/__support/str_to_float.h
+++ b/libc/src/__support/str_to_float.h
@@ -20,42 +20,42 @@
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);
}
@@ -77,9 +77,9 @@ static inline uint64_t high64(__uint128_t num) {
// 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,
- typename fputil::FPBits<T>::UIntType *outputMantissa,
- uint32_t *outputExp2) {
+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;
@@ -96,71 +96,74 @@ eiselLemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
}
// 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;
}
@@ -180,14 +183,14 @@ constexpr int32_t NUM_POWERS_OF_TWO =
// link: https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
template <class T>
static inline void
-simpleDecimalConversion(const char *__restrict numStart,
- typename fputil::FPBits<T>::UIntType *outputMantissa,
- uint32_t *outputExp2) {
+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;
@@ -195,19 +198,19 @@ simpleDecimalConversion(const char *__restrict numStart,
// 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;
@@ -215,31 +218,31 @@ simpleDecimalConversion(const char *__restrict numStart,
}
// 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
@@ -247,20 +250,20 @@ simpleDecimalConversion(const char *__restrict numStart,
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) {
@@ -272,19 +275,19 @@ simpleDecimalConversion(const char *__restrict numStart,
// 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;
}
@@ -292,7 +295,7 @@ simpleDecimalConversion(const char *__restrict numStart,
errno = ERANGE;
}
- *outputMantissa = finalMantissa;
+ *outputMantissa = final_mantissa;
*outputExp2 = exp2;
}
@@ -308,21 +311,21 @@ template <class T> class ClingerConsts;
template <> class ClingerConsts<float> {
public:
- static constexpr float powersOfTenArray[] = {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 float POWERS_OF_TEN_ARRAY[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
+ 1e6, 1e7, 1e8, 1e9, 1e10};
+ 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
@@ -331,45 +334,44 @@ template <> class ClingerConsts<double> {
// Fast Path, as described above.
template <class T>
static inline bool
-clingerFastPath(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) {
+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>::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;
}
@@ -380,25 +382,26 @@ clingerFastPath(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
// and outputExp2.
template <class T>
static inline void
-decimalExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
- const char *__restrict numStart, bool truncated,
- typename fputil::FPBits<T>::UIntType *outputMantissa,
- uint32_t *outputExp2) {
+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;
@@ -407,29 +410,29 @@ decimalExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
}
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;
}
@@ -440,46 +443,47 @@ decimalExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
// 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,
- bool truncated,
- typename fputil::FPBits<T>::UIntType *outputMantissa,
- uint32_t *outputExp2) {
+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;
@@ -488,39 +492,39 @@ binaryExpToFloat(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
}
}
- 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
@@ -545,18 +549,18 @@ static inline bool is_float_hex_start(const char *__restrict src,
// here.
template <class T>
static inline bool
-decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
- char **__restrict strEnd,
- typename fputil::FPBits<T>::UIntType *outputMantissa,
- uint32_t *outputExponent) {
+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;
@@ -564,22 +568,22 @@ decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
// 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;
}
@@ -587,11 +591,11 @@ decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
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;
}
@@ -599,20 +603,20 @@ decimalStringToFloat(const char *__restrict src, const char 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;
}
}
@@ -622,8 +626,8 @@ decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
*outputMantissa = 0;
*outputExponent = 0;
} else {
- decimalExpToFloat<T>(mantissa, exponent, numStart, truncated,
- outputMantissa, outputExponent);
+ decimal_exp_to_float<T>(mantissa, exponent, num_start, truncated,
+ outputMantissa, outputExponent);
}
return true;
}
@@ -635,18 +639,18 @@ decimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
// 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,
+ char **__restrict strEnd,
+ typename fputil::FPBits<T>::UIntType *outputMantissa,
+ uint32_t *outputExponent) {
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;
@@ -654,35 +658,35 @@ hexadecimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
// 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;
}
@@ -690,7 +694,7 @@ hexadecimalStringToFloat(const char *__restrict src, const char 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.
@@ -699,13 +703,13 @@ hexadecimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
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;
}
}
@@ -714,8 +718,8 @@ hexadecimalStringToFloat(const char *__restrict src, const char DECIMAL_POINT,
*outputMantissa = 0;
*outputExponent = 0;
} else {
- binaryExpToFloat<T>(mantissa, exponent, truncated, outputMantissa,
- outputExponent);
+ binary_exp_to_float<T>(mantissa, exponent, truncated, outputMantissa,
+ outputExponent);
}
return true;
}
@@ -727,20 +731,20 @@ 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;
@@ -749,74 +753,74 @@ static inline T strtofloatingpoint(const char *__restrict src,
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 {
@@ -824,9 +828,9 @@ static inline T strtofloatingpoint(const char *__restrict src,
}
}
}
- 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);
}
diff --git a/libc/src/__support/str_to_integer.h b/libc/src/__support/str_to_integer.h
index 3ecf098e1c204..c3505c3713fa6 100644
--- a/libc/src/__support/str_to_integer.h
+++ b/libc/src/__support/str_to_integer.h
@@ -92,16 +92,16 @@ static inline T strtointeger(const char *__restrict 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)
@@ -113,19 +113,19 @@ static inline T strtointeger(const char *__restrict 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;
@@ -135,8 +135,8 @@ static inline T strtointeger(const char *__restrict src,
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();
diff --git a/libc/src/assert/__assert_fail.cpp b/libc/src/assert/__assert_fail.cpp
index 614e130276338..0fe2ca6da87c1 100644
--- a/libc/src/assert/__assert_fail.cpp
+++ b/libc/src/assert/__assert_fail.cpp
@@ -18,7 +18,7 @@ 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);
@@ -27,12 +27,12 @@ static void writeToStderr(const char *s) {
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();
}
diff --git a/libc/src/errno/__errno_location.cpp b/libc/src/errno/__errno_location.cpp
index 54c5acb084489..b4860ebe7b7f3 100644
--- a/libc/src/errno/__errno_location.cpp
+++ b/libc/src/errno/__errno_location.cpp
@@ -12,11 +12,11 @@
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
diff --git a/libc/src/fenv/feclearexcept.cpp b/libc/src/fenv/feclearexcept.cpp
index 7a1114e4150f8..3c24c63446bcd 100644
--- a/libc/src/fenv/feclearexcept.cpp
+++ b/libc/src/fenv/feclearexcept.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feclearexcept, (int e)) {
- return fputil::clearExcept(e);
+ return fputil::clear_except(e);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fedisableexcept.cpp b/libc/src/fenv/fedisableexcept.cpp
index a31bb947f4612..b7b7d27516d6d 100644
--- a/libc/src/fenv/fedisableexcept.cpp
+++ b/libc/src/fenv/fedisableexcept.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fedisableexcept, (int e)) {
- return fputil::disableExcept(e);
+ return fputil::disable_except(e);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/feenableexcept.cpp b/libc/src/fenv/feenableexcept.cpp
index 1046babc31fce..9797d66c034cb 100644
--- a/libc/src/fenv/feenableexcept.cpp
+++ b/libc/src/fenv/feenableexcept.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feenableexcept, (int e)) {
- return fputil::enableExcept(e);
+ return fputil::enable_except(e);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fegetenv.cpp b/libc/src/fenv/fegetenv.cpp
index 135adc6de5693..9ae7782dbd70e 100644
--- a/libc/src/fenv/fegetenv.cpp
+++ b/libc/src/fenv/fegetenv.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fegetenv, (fenv_t * envp)) {
- return fputil::getEnv(envp);
+ return fputil::get_env(envp);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fegetexcept.cpp b/libc/src/fenv/fegetexcept.cpp
index 1c9ec376fcf22..0a472c85a5c06 100644
--- a/libc/src/fenv/fegetexcept.cpp
+++ b/libc/src/fenv/fegetexcept.cpp
@@ -12,6 +12,6 @@
namespace __llvm_libc {
-LLVM_LIBC_FUNCTION(int, fegetexcept, ()) { return fputil::getExcept(); }
+LLVM_LIBC_FUNCTION(int, fegetexcept, ()) { return fputil::get_except(); }
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fegetexceptflag.cpp b/libc/src/fenv/fegetexceptflag.cpp
index 131d703e17156..dfe2a6396e4f7 100644
--- a/libc/src/fenv/fegetexceptflag.cpp
+++ b/libc/src/fenv/fegetexceptflag.cpp
@@ -16,7 +16,7 @@ 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;
}
diff --git a/libc/src/fenv/fegetround.cpp b/libc/src/fenv/fegetround.cpp
index ade5088f40485..3369037c1e5af 100644
--- a/libc/src/fenv/fegetround.cpp
+++ b/libc/src/fenv/fegetround.cpp
@@ -12,6 +12,6 @@
namespace __llvm_libc {
-LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::getRound(); }
+LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::get_round(); }
} // namespace __llvm_libc
diff --git a/libc/src/fenv/feholdexcept.cpp b/libc/src/fenv/feholdexcept.cpp
index 61aeb8ab75745..3e31e817c60d5 100644
--- a/libc/src/fenv/feholdexcept.cpp
+++ b/libc/src/fenv/feholdexcept.cpp
@@ -15,10 +15,10 @@
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;
}
diff --git a/libc/src/fenv/feraiseexcept.cpp b/libc/src/fenv/feraiseexcept.cpp
index 1f8c16c233722..a14ac864926e2 100644
--- a/libc/src/fenv/feraiseexcept.cpp
+++ b/libc/src/fenv/feraiseexcept.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feraiseexcept, (int e)) {
- return fputil::raiseExcept(e);
+ return fputil::raise_except(e);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fesetenv.cpp b/libc/src/fenv/fesetenv.cpp
index 57db2537de0a6..2b10e0b96bb69 100644
--- a/libc/src/fenv/fesetenv.cpp
+++ b/libc/src/fenv/fesetenv.cpp
@@ -13,7 +13,7 @@
namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fesetenv, (const fenv_t *envp)) {
- return fputil::setEnv(envp);
+ return fputil::set_env(envp);
}
} // namespace __llvm_libc
diff --git a/libc/src/fenv/fesetexceptflag.cpp b/libc/src/fenv/fesetexceptflag.cpp
index 7e480e39d24cf..93f22a4be1cba 100644
--- a/libc/src/fenv/fesetexceptflag.cpp
+++ b/libc/src/fenv/fesetexceptflag.cpp
@@ -21,8 +21,8 @@ LLVM_LIBC_FUNCTION(int, fesetexceptflag,
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
diff --git a/libc/src/fenv/fesetround.cpp b/libc/src/fenv/fesetround.cpp
index 041523afc4c97..a118e2ffa7e4c 100644
--- a/libc/src/fenv/fesetround.cpp
+++ b/libc/src/fenv/fesetround.cpp
@@ -12,6 +12,6 @@
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
diff --git a/libc/src/fenv/fetestexcept.cpp b/libc/src/fenv/fetestexcept.cpp
index 59cfca5d1387d..52455ed334786 100644
--- a/libc/src/fenv/fetestexcept.cpp
+++ b/libc/src/fenv/fetestexcept.cpp
@@ -12,6 +12,8 @@
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
diff --git a/libc/src/fenv/feupdateenv.cpp b/libc/src/fenv/feupdateenv.cpp
index 6a8697265ef9e..1606dd2233005 100644
--- a/libc/src/fenv/feupdateenv.cpp
+++ b/libc/src/fenv/feupdateenv.cpp
@@ -15,10 +15,10 @@
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
diff --git a/libc/src/inttypes/imaxdiv.cpp b/libc/src/inttypes/imaxdiv.cpp
index 6189fc197b1e4..9ed6a1b46e5ad 100644
--- a/libc/src/inttypes/imaxdiv.cpp
+++ b/libc/src/inttypes/imaxdiv.cpp
@@ -14,7 +14,7 @@ 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;
}
diff --git a/libc/src/math/generic/cosf.cpp b/libc/src/math/generic/cosf.cpp
index 15911a520011f..46e7466a233c1 100644
--- a/libc/src/math/generic/cosf.cpp
+++ b/libc/src/math/generic/cosf.cpp
@@ -25,7 +25,7 @@ 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;
@@ -41,7 +41,7 @@ LLVM_LIBC_FUNCTION(float, cosf, (float y)) {
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)) {
@@ -54,7 +54,7 @@ LLVM_LIBC_FUNCTION(float, cosf, (float y)) {
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);
}
diff --git a/libc/src/math/generic/dp_trig.cpp b/libc/src/math/generic/dp_trig.cpp
index 77077925e4510..3fa9d4a0ca0fe 100644
--- a/libc/src/math/generic/dp_trig.cpp
+++ b/libc/src/math/generic/dp_trig.cpp
@@ -30,7 +30,7 @@ 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;
diff --git a/libc/src/math/generic/expm1f.cpp b/libc/src/math/generic/expm1f.cpp
index e893c606d8524..cb3ba325c8f96 100644
--- a/libc/src/math/generic/expm1f.cpp
+++ b/libc/src/math/generic/expm1f.cpp
@@ -23,12 +23,12 @@ namespace __llvm_libc {
//
// 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,
diff --git a/libc/src/math/generic/llrint.cpp b/libc/src/math/generic/llrint.cpp
index cf0e45aa09f7e..66097f88e5abc 100644
--- a/libc/src/math/generic/llrint.cpp
+++ b/libc/src/math/generic/llrint.cpp
@@ -13,8 +13,9 @@
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
diff --git a/libc/src/math/generic/llrintf.cpp b/libc/src/math/generic/llrintf.cpp
index 96feea0f0deee..a4ae5721b77bb 100644
--- a/libc/src/math/generic/llrintf.cpp
+++ b/libc/src/math/generic/llrintf.cpp
@@ -13,7 +13,8 @@
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);
}
diff --git a/libc/src/math/generic/llrintl.cpp b/libc/src/math/generic/llrintl.cpp
index ab1f0066105b3..9d02b7411b893 100644
--- a/libc/src/math/generic/llrintl.cpp
+++ b/libc/src/math/generic/llrintl.cpp
@@ -13,8 +13,8 @@
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
diff --git a/libc/src/math/generic/llround.cpp b/libc/src/math/generic/llround.cpp
index c424b19fe314e..b3dfd2f8783e0 100644
--- a/libc/src/math/generic/llround.cpp
+++ b/libc/src/math/generic/llround.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/llroundf.cpp b/libc/src/math/generic/llroundf.cpp
index 7dc312694f3c0..8784b0c0d6932 100644
--- a/libc/src/math/generic/llroundf.cpp
+++ b/libc/src/math/generic/llroundf.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/llroundl.cpp b/libc/src/math/generic/llroundl.cpp
index 099ad2f6fe93b..30dec140e1559 100644
--- a/libc/src/math/generic/llroundl.cpp
+++ b/libc/src/math/generic/llroundl.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/lrint.cpp b/libc/src/math/generic/lrint.cpp
index 66fa8956c9b91..162fa03e419ef 100644
--- a/libc/src/math/generic/lrint.cpp
+++ b/libc/src/math/generic/lrint.cpp
@@ -13,7 +13,8 @@
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
diff --git a/libc/src/math/generic/lrintf.cpp b/libc/src/math/generic/lrintf.cpp
index 246bf59d9c5c2..6444ecc2c3469 100644
--- a/libc/src/math/generic/lrintf.cpp
+++ b/libc/src/math/generic/lrintf.cpp
@@ -13,7 +13,8 @@
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
diff --git a/libc/src/math/generic/lrintl.cpp b/libc/src/math/generic/lrintl.cpp
index d8490bc19e3e7..3fcd97cc6d19f 100644
--- a/libc/src/math/generic/lrintl.cpp
+++ b/libc/src/math/generic/lrintl.cpp
@@ -13,8 +13,8 @@
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
diff --git a/libc/src/math/generic/lround.cpp b/libc/src/math/generic/lround.cpp
index cc575c03b2f09..413c06ff736fa 100644
--- a/libc/src/math/generic/lround.cpp
+++ b/libc/src/math/generic/lround.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/lroundf.cpp b/libc/src/math/generic/lroundf.cpp
index 40778c6d231cb..919ae35aa0065 100644
--- a/libc/src/math/generic/lroundf.cpp
+++ b/libc/src/math/generic/lroundf.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/lroundl.cpp b/libc/src/math/generic/lroundl.cpp
index c48d7a400821d..9ffa36e0c7a0b 100644
--- a/libc/src/math/generic/lroundl.cpp
+++ b/libc/src/math/generic/lroundl.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/math_utils.h b/libc/src/math/generic/math_utils.h
index 11c2bd1f0a4ae..ed9a1910a90ee 100644
--- a/libc/src/math/generic/math_utils.h
+++ b/libc/src/math/generic/math_utils.h
@@ -69,7 +69,8 @@ template <typename T> static inline T opt_barrier(T x) {
}
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;
};
diff --git a/libc/src/math/generic/nearbyint.cpp b/libc/src/math/generic/nearbyint.cpp
index ee2a6bc3ee3a6..b1becee4dd094 100644
--- a/libc/src/math/generic/nearbyint.cpp
+++ b/libc/src/math/generic/nearbyint.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/nearbyintf.cpp b/libc/src/math/generic/nearbyintf.cpp
index 5d143e4e8e49d..1b0c2cc0aa629 100644
--- a/libc/src/math/generic/nearbyintf.cpp
+++ b/libc/src/math/generic/nearbyintf.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/nearbyintl.cpp b/libc/src/math/generic/nearbyintl.cpp
index 1f15e2bb60bf3..75eb49e5692b0 100644
--- a/libc/src/math/generic/nearbyintl.cpp
+++ b/libc/src/math/generic/nearbyintl.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/rint.cpp b/libc/src/math/generic/rint.cpp
index 2d50d8ebfe13b..9427b6ffce478 100644
--- a/libc/src/math/generic/rint.cpp
+++ b/libc/src/math/generic/rint.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/rintf.cpp b/libc/src/math/generic/rintf.cpp
index 7e741e001a249..8c2e9c9ba700c 100644
--- a/libc/src/math/generic/rintf.cpp
+++ b/libc/src/math/generic/rintf.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/rintl.cpp b/libc/src/math/generic/rintl.cpp
index 359f14a318335..493d825e0468a 100644
--- a/libc/src/math/generic/rintl.cpp
+++ b/libc/src/math/generic/rintl.cpp
@@ -13,7 +13,7 @@
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
diff --git a/libc/src/math/generic/sincosf.cpp b/libc/src/math/generic/sincosf.cpp
index c032cd3565afc..44a39d6c95edf 100644
--- a/libc/src/math/generic/sincosf.cpp
+++ b/libc/src/math/generic/sincosf.cpp
@@ -25,7 +25,7 @@ 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;
@@ -47,7 +47,7 @@ LLVM_LIBC_FUNCTION(void, sincosf, (float y, float *sinp, float *cosp)) {
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))) {
@@ -60,7 +60,7 @@ LLVM_LIBC_FUNCTION(void, sincosf, (float y, float *sinp, float *cosp)) {
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 {
diff --git a/libc/src/math/generic/sincosf_data.cpp b/libc/src/math/generic/sincosf_data.cpp
index 50984570b55fe..d86bae702d51d 100644
--- a/libc/src/math/generic/sincosf_data.cpp
+++ b/libc/src/math/generic/sincosf_data.cpp
@@ -15,7 +15,7 @@ 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),
@@ -42,7 +42,7 @@ const sincos_t __sincosf_table[2] = {
// 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,
diff --git a/libc/src/math/generic/sincosf_utils.h b/libc/src/math/generic/sincosf_utils.h
index 8c54cb9c1d904..3bbb4acc5a6d3 100644
--- a/libc/src/math/generic/sincosf_utils.h
+++ b/libc/src/math/generic/sincosf_utils.h
@@ -30,10 +30,10 @@ typedef struct {
} 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) {
@@ -117,7 +117,7 @@ static inline double reduce_fast(double x, const sincos_t *p, int *np) {
// 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;
diff --git a/libc/src/math/generic/sinf.cpp b/libc/src/math/generic/sinf.cpp
index 467480e04de60..50fb8c3522642 100644
--- a/libc/src/math/generic/sinf.cpp
+++ b/libc/src/math/generic/sinf.cpp
@@ -25,7 +25,7 @@ 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;
@@ -45,7 +45,7 @@ LLVM_LIBC_FUNCTION(float, sinf, (float y)) {
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)) {
@@ -58,7 +58,7 @@ LLVM_LIBC_FUNCTION(float, sinf, (float y)) {
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);
}
diff --git a/libc/src/signal/linux/sigaction.cpp b/libc/src/signal/linux/sigaction.cpp
index 602fc71bf390c..bd3581ba08587 100644
--- a/libc/src/signal/linux/sigaction.cpp
+++ b/libc/src/signal/linux/sigaction.cpp
@@ -21,7 +21,7 @@ namespace __llvm_libc {
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;
@@ -33,7 +33,7 @@ LLVM_LIBC_FUNCTION(int, sigaction,
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;
@@ -49,7 +49,7 @@ LLVM_LIBC_FUNCTION(int, sigaction,
}
if (libc_old)
- copySigaction(*libc_old, kernel_old);
+ copy_sigaction(*libc_old, kernel_old);
return 0;
}
diff --git a/libc/src/signal/linux/sigemptyset.cpp b/libc/src/signal/linux/sigemptyset.cpp
index bce5fea7c963b..9ae8a7330f207 100644
--- a/libc/src/signal/linux/sigemptyset.cpp
+++ b/libc/src/signal/linux/sigemptyset.cpp
@@ -20,7 +20,7 @@ LLVM_LIBC_FUNCTION(int, sigemptyset, (sigset_t * set)) {
llvmlibc_errno = EINVAL;
return -1;
}
- *set = __llvm_libc::Sigset::emptySet();
+ *set = __llvm_libc::Sigset::empty_set();
return 0;
}
diff --git a/libc/src/signal/linux/signal.h b/libc/src/signal/linux/signal.h
index 89b471b4079e4..a59a56ced5d6a 100644
--- a/libc/src/signal/linux/signal.h
+++ b/libc/src/signal/linux/signal.h
@@ -21,32 +21,32 @@ namespace __llvm_libc {
// Using this internally defined type will make it easier in the future to port
// to
diff erent 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));
}
diff --git a/libc/src/stdlib/abs.cpp b/libc/src/stdlib/abs.cpp
index d6111aae75414..eef7937067eb8 100644
--- a/libc/src/stdlib/abs.cpp
+++ b/libc/src/stdlib/abs.cpp
@@ -12,6 +12,6 @@
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
diff --git a/libc/src/stdlib/div.cpp b/libc/src/stdlib/div.cpp
index 042346dd8f598..44f1d9fd1bb9d 100644
--- a/libc/src/stdlib/div.cpp
+++ b/libc/src/stdlib/div.cpp
@@ -14,7 +14,7 @@ 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;
}
diff --git a/libc/src/stdlib/labs.cpp b/libc/src/stdlib/labs.cpp
index 8dffc1ef2eb24..a32f3055c3332 100644
--- a/libc/src/stdlib/labs.cpp
+++ b/libc/src/stdlib/labs.cpp
@@ -12,6 +12,6 @@
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
diff --git a/libc/src/stdlib/ldiv.cpp b/libc/src/stdlib/ldiv.cpp
index fdac26045724d..b08dc65c7c7e2 100644
--- a/libc/src/stdlib/ldiv.cpp
+++ b/libc/src/stdlib/ldiv.cpp
@@ -14,7 +14,7 @@ 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;
}
diff --git a/libc/src/stdlib/llabs.cpp b/libc/src/stdlib/llabs.cpp
index d74c7f4b2091c..a72f3625567d8 100644
--- a/libc/src/stdlib/llabs.cpp
+++ b/libc/src/stdlib/llabs.cpp
@@ -12,6 +12,6 @@
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
diff --git a/libc/src/stdlib/lldiv.cpp b/libc/src/stdlib/lldiv.cpp
index 958b01fcc01ef..ef3d037f1ded2 100644
--- a/libc/src/stdlib/lldiv.cpp
+++ b/libc/src/stdlib/lldiv.cpp
@@ -14,7 +14,7 @@ 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;
}
diff --git a/libc/src/string/memccpy.cpp b/libc/src/string/memccpy.cpp
index 782beee947636..989a24d0852c6 100644
--- a/libc/src/string/memccpy.cpp
+++ b/libc/src/string/memccpy.cpp
@@ -17,17 +17,17 @@ 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;
}
diff --git a/libc/src/string/memmove.cpp b/libc/src/string/memmove.cpp
index d4c8e0bccd8a9..ce411fd1641a6 100644
--- a/libc/src/string/memmove.cpp
+++ b/libc/src/string/memmove.cpp
@@ -40,7 +40,7 @@ LLVM_LIBC_FUNCTION(void *, memmove,
// 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<ptr
diff _t>(count)) {
inline_memcpy(dest_c, src_c, count);
return dest_c;
diff --git a/libc/src/string/memory_utils/bcmp_implementations.h b/libc/src/string/memory_utils/bcmp_implementations.h
index ec94af28c6a68..c26e38e51adf1 100644
--- a/libc/src/string/memory_utils/bcmp_implementations.h
+++ b/libc/src/string/memory_utils/bcmp_implementations.h
@@ -18,13 +18,13 @@
namespace __llvm_libc {
// Fixed-size
diff erence between 'lhs' and 'rhs'.
-template <typename Element> bool Differs(const char *lhs, const char *rhs) {
- return !Element::Equals(lhs, rhs);
+template <typename Element> bool
diff ers(const char *lhs, const char *rhs) {
+ return !Element::equals(lhs, rhs);
}
// Runtime-size
diff erence 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
diff ers(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) {
@@ -38,22 +38,22 @@ static inline int inline_bcmp(const char *lhs, const char *rhs, size_t count) {
if (count == 0)
return 0;
if (count == 1)
- return Differs<_1>(lhs, rhs);
+ return
diff ers<_1>(lhs, rhs);
if (count == 2)
- return Differs<_2>(lhs, rhs);
+ return
diff ers<_2>(lhs, rhs);
if (count == 3)
- return Differs<_3>(lhs, rhs);
+ return
diff ers<_3>(lhs, rhs);
if (count <= 8)
- return Differs<HeadTail<_4>>(lhs, rhs, count);
+ return
diff ers<HeadTail<_4>>(lhs, rhs, count);
if (count <= 16)
- return Differs<HeadTail<_8>>(lhs, rhs, count);
+ return
diff ers<HeadTail<_8>>(lhs, rhs, count);
if (count <= 32)
- return Differs<HeadTail<_16>>(lhs, rhs, count);
+ return
diff ers<HeadTail<_16>>(lhs, rhs, count);
if (count <= 64)
- return Differs<HeadTail<_32>>(lhs, rhs, count);
+ return
diff ers<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
diff ers<HeadTail<_64>>(lhs, rhs, count);
+ return
diff ers<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
}
} // namespace __llvm_libc
diff --git a/libc/src/string/memory_utils/elements.h b/libc/src/string/memory_utils/elements.h
index f99e03d9d47b6..09a24458d2cad 100644
--- a/libc/src/string/memory_utils/elements.h
+++ b/libc/src/string/memory_utils/elements.h
@@ -26,58 +26,58 @@ namespace __llvm_libc {
// 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
// ----------------------------------
@@ -86,62 +86,63 @@ template <typename Element> struct Storage { char bytes[Element::kSize]; };
// 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.
@@ -150,128 +151,128 @@ template <typename Element> struct Repeated<Element, 0> {
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
@@ -280,37 +281,37 @@ template <typename T> struct Tail {
// [__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);
}
};
@@ -325,48 +326,48 @@ template <typename T> struct HeadTail {
// [______________________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);
}
};
@@ -374,14 +375,14 @@ 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;
@@ -392,7 +393,7 @@ template <size_t Alignment> struct AlignHelper<Arg::_1, Alignment> {
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;
@@ -410,41 +411,42 @@ template <size_t Alignment> struct AlignHelper<Arg::_2, Alignment> {
// - 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);
}
};
};
@@ -452,37 +454,38 @@ template <typename AlignmentT, Arg AlignOn = Arg::_1> struct Align {
// An operation that allows to skip the specified amount of bytes.
template <ptr
diff _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);
}
};
};
@@ -499,29 +502,29 @@ namespace builtin {
#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
}
@@ -531,29 +534,29 @@ template <size_t Size> struct Builtin {
#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];
}
};
@@ -576,66 +579,65 @@ 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;
}
diff --git a/libc/src/string/memory_utils/elements_aarch64.h b/libc/src/string/memory_utils/elements_aarch64.h
index 57d56a482d8ec..a1d88c5f83aaa 100644
--- a/libc/src/string/memory_utils/elements_aarch64.h
+++ b/libc/src/string/memory_utils/elements_aarch64.h
@@ -25,15 +25,15 @@ 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));
}
};
@@ -53,8 +53,8 @@ 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");
}
};
@@ -64,7 +64,7 @@ inline static bool AArch64ZVA(char *dst, size_t count) {
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;
}
@@ -81,8 +81,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));
@@ -92,7 +92,7 @@ struct N32 {
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));
@@ -105,7 +105,7 @@ struct N32 {
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);
}
};
diff --git a/libc/src/string/memory_utils/elements_x86.h b/libc/src/string/memory_utils/elements_x86.h
index b67569bdd8cf2..e09e62689e8fc 100644
--- a/libc/src/string/memory_utils/elements_x86.h
+++ b/libc/src/string/memory_utils/elements_x86.h
@@ -30,30 +30,30 @@ 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];
@@ -62,22 +62,22 @@ template <typename Base> struct Vector : public Base {
};
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;
}
@@ -87,22 +87,22 @@ 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;
@@ -113,21 +113,21 @@ 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,
@@ -169,7 +169,7 @@ 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");
}
};
diff --git a/libc/src/string/memory_utils/memcmp_implementations.h b/libc/src/string/memory_utils/memcmp_implementations.h
index a2934cefe4981..f2079468f2be3 100644
--- a/libc/src/string/memory_utils/memcmp_implementations.h
+++ b/libc/src/string/memory_utils/memcmp_implementations.h
@@ -27,22 +27,22 @@ static inline int inline_memcmp(const char *lhs, const char *rhs,
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
@@ -51,27 +51,27 @@ static inline int inline_memcmp(const char *lhs, const char *rhs,
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
@@ -81,22 +81,22 @@ static inline int inline_memcmp(const char *lhs, const char *rhs,
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
}
diff --git a/libc/src/string/memory_utils/memcpy_implementations.h b/libc/src/string/memory_utils/memcpy_implementations.h
index 2a738f7ecf1d3..8da4085de9aac 100644
--- a/libc/src/string/memory_utils/memcpy_implementations.h
+++ b/libc/src/string/memory_utils/memcpy_implementations.h
@@ -46,13 +46,13 @@ static inline void inline_memcpy(char *__restrict dst,
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
@@ -60,7 +60,7 @@ static inline void inline_memcpy(char *__restrict dst,
#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;
@@ -68,35 +68,35 @@ static inline void inline_memcpy(char *__restrict dst,
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
@@ -105,24 +105,24 @@ static inline void inline_memcpy(char *__restrict dst,
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
@@ -131,24 +131,24 @@ static inline void inline_memcpy(char *__restrict dst,
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
}
diff --git a/libc/src/string/memory_utils/memset_implementations.h b/libc/src/string/memory_utils/memset_implementations.h
index e34b13a872fca..3fffc03e6439b 100644
--- a/libc/src/string/memory_utils/memset_implementations.h
+++ b/libc/src/string/memory_utils/memset_implementations.h
@@ -36,8 +36,8 @@ namespace __llvm_libc {
// 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
@@ -57,22 +57,22 @@ inline static void inline_memset(char *dst, unsigned char value, size_t count) {
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
@@ -81,27 +81,27 @@ inline static void inline_memset(char *dst, unsigned char value, size_t count) {
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
@@ -111,22 +111,22 @@ inline static void inline_memset(char *dst, unsigned char value, size_t count) {
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
}
diff --git a/libc/src/string/strcat.cpp b/libc/src/string/strcat.cpp
index fef2758f04ced..6af5e514c407d 100644
--- a/libc/src/string/strcat.cpp
+++ b/libc/src/string/strcat.cpp
@@ -16,10 +16,10 @@ 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;
}
diff --git a/libc/src/string/strncat.cpp b/libc/src/string/strncat.cpp
index 968c1e2703bd8..06e69eacd355b 100644
--- a/libc/src/string/strncat.cpp
+++ b/libc/src/string/strncat.cpp
@@ -17,11 +17,11 @@ 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;
}
diff --git a/libc/src/threads/linux/Thread.h b/libc/src/threads/linux/Thread.h
index 5adbbfea5f572..55aa2719673fb 100644
--- a/libc/src/threads/linux/Thread.h
+++ b/libc/src/threads/linux/Thread.h
@@ -17,8 +17,8 @@
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
diff --git a/libc/src/threads/linux/thrd_create.cpp b/libc/src/threads/linux/thrd_create.cpp
index 59d260da46dfd..f2464d4075eaa 100644
--- a/libc/src/threads/linux/thrd_create.cpp
+++ b/libc/src/threads/linux/thrd_create.cpp
@@ -52,18 +52,18 @@ LLVM_LIBC_FUNCTION(int, thrd_create,
// 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
@@ -72,7 +72,8 @@ LLVM_LIBC_FUNCTION(int, thrd_create,
// 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;
@@ -83,9 +84,8 @@ LLVM_LIBC_FUNCTION(int, thrd_create,
// 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,
- &thread->__tid, clear_tid_address, 0);
+ clone_result = __llvm_libc::syscall(SYS_clone, clone_flags, adjusted_stack,
+ &thread->__tid, clear_tid_address, 0);
if (clone_result == 0) {
start_thread();
diff --git a/libc/src/threads/linux/thrd_join.cpp b/libc/src/threads/linux/thrd_join.cpp
index 1262a5f17732f..3c779495def58 100644
--- a/libc/src/threads/linux/thrd_join.cpp
+++ b/libc/src/threads/linux/thrd_join.cpp
@@ -31,7 +31,7 @@ LLVM_LIBC_FUNCTION(int, thrd_join, (thrd_t * thread, int *retval)) {
// 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;
diff --git a/libc/src/time/asctime.cpp b/libc/src/time/asctime.cpp
index cdf5391d29ebf..3ccfb042e1449 100644
--- a/libc/src/time/asctime.cpp
+++ b/libc/src/time/asctime.cpp
@@ -15,8 +15,8 @@ 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
diff --git a/libc/src/time/asctime_r.cpp b/libc/src/time/asctime_r.cpp
index fadc13e3b5a02..f957dac366836 100644
--- a/libc/src/time/asctime_r.cpp
+++ b/libc/src/time/asctime_r.cpp
@@ -16,7 +16,7 @@ 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
diff --git a/libc/src/time/mktime.cpp b/libc/src/time/mktime.cpp
index 35970b1c910b2..ea748ce4ab727 100644
--- a/libc/src/time/mktime.cpp
+++ b/libc/src/time/mktime.cpp
@@ -16,39 +16,39 @@ namespace __llvm_libc {
using __llvm_libc::time_utils::TimeConstants;
-static constexpr int NonLeapYearDaysInMonth[] = {31, 28, 31, 30, 31, 30,
- 31, 31, 30, 31, 30, 31};
+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.
@@ -59,57 +59,57 @@ LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
// 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);
}
diff --git a/libc/src/time/time_utils.cpp b/libc/src/time/time_utils.cpp
index 11ac2fb0d9a0b..ca5f16cb7c9a8 100644
--- a/libc/src/time/time_utils.cpp
+++ b/libc/src/time/time_utils.cpp
@@ -43,61 +43,63 @@ static int64_t computeRemainingYears(int64_t daysPerYears,
//
// 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 +
@@ -108,8 +110,8 @@ int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm) {
!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) {
@@ -117,26 +119,26 @@ int64_t UpdateFromSeconds(int64_t total_seconds, struct tm *tm) {
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;
diff --git a/libc/src/time/time_utils.h b/libc/src/time/time_utils.h
index c1c7735f49060..62a347f61e8ef 100644
--- a/libc/src/time/time_utils.h
+++ b/libc/src/time/time_utils.h
@@ -22,92 +22,92 @@ 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 int64_t SECONDS_UNTIL2000_MARCH_FIRST =
+ (946684800LL + SECONDS_PER_DAY * (31 + 29));
+ static constexpr int WEEK_DAY_OF2000_MARCH_FIRST = 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 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;
@@ -117,8 +117,8 @@ 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;
}
diff --git a/libc/test/src/__support/endian_test.cpp b/libc/test/src/__support/endian_test.cpp
index e06355759e0fa..6b90beb9f5bdd 100644
--- a/libc/test/src/__support/endian_test.cpp
+++ b/libc/test/src/__support/endian_test.cpp
@@ -14,19 +14,19 @@ 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) {
diff --git a/libc/test/src/__support/high_precision_decimal_test.cpp b/libc/test/src/__support/high_precision_decimal_test.cpp
index 526452f23694b..7b04d78501d5e 100644
--- a/libc/test/src/__support/high_precision_decimal_test.cpp
+++ b/libc/test/src/__support/high_precision_decimal_test.cpp
@@ -13,33 +13,33 @@
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
@@ -49,8 +49,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
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
@@ -60,8 +60,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
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
@@ -70,8 +70,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
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
@@ -81,14 +81,14 @@ TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
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
@@ -103,8 +103,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, MediumShift) {
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
@@ -118,14 +118,14 @@ TEST(LlvmLibcHighPrecisionDecimalTest, MediumShift) {
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
@@ -158,8 +158,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
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
@@ -173,14 +173,14 @@ TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
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.
@@ -204,8 +204,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
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
@@ -242,8 +242,8 @@ TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
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
@@ -262,22 +262,22 @@ TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
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.
@@ -315,52 +315,52 @@ TEST(LlvmLibcHighPrecisionDecimalTest, VeryBigShift) {
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.)
@@ -368,8 +368,9 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
// 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(
@@ -377,5 +378,5 @@ TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
__uint128_t result = __uint128_t(1) << 100;
- EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), result);
+ EXPECT_EQ(hpd.round_to_integer_type<__uint128_t>(), result);
}
diff --git a/libc/test/src/__support/str_to_float_test.cpp b/libc/test/src/__support/str_to_float_test.cpp
index 0acb40e273f44..5728185e54bb5 100644
--- a/libc/test/src/__support/str_to_float_test.cpp
+++ b/libc/test/src/__support/str_to_float_test.cpp
@@ -23,7 +23,7 @@ class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
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);
@@ -36,7 +36,7 @@ class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
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));
}
@@ -50,7 +50,7 @@ class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
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);
@@ -66,7 +66,7 @@ class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
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);
@@ -77,38 +77,38 @@ class LlvmLibcStrToFloatTest : public __llvm_libc::testing::Test {
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) {
@@ -171,16 +171,16 @@ TEST_F(LlvmLibcStrToFloatTest, EiselLemireFallbackStates) {
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));
}
@@ -236,7 +236,7 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
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));
@@ -246,7 +246,7 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
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));
@@ -258,7 +258,7 @@ TEST(LlvmLibcStrToFloatTest, SimpleDecimalConversionExtraTypes) {
// 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));
diff --git a/libc/test/src/fenv/enabled_exceptions_test.cpp b/libc/test/src/fenv/enabled_exceptions_test.cpp
index bf04b6418eb45..acc3b09d4aca9 100644
--- a/libc/test/src/fenv/enabled_exceptions_test.cpp
+++ b/libc/test/src/fenv/enabled_exceptions_test.cpp
@@ -29,9 +29,9 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// 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)
@@ -50,8 +50,8 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
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,
@@ -69,12 +69,12 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
// a death test which runs this closure in a
diff erent 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);
}
}
diff --git a/libc/test/src/fenv/exception_flags_test.cpp b/libc/test/src/fenv/exception_flags_test.cpp
index db23fd9809489..bb2220c390b18 100644
--- a/libc/test/src/fenv/exception_flags_test.cpp
+++ b/libc/test/src/fenv/exception_flags_test.cpp
@@ -17,8 +17,8 @@
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};
@@ -27,32 +27,32 @@ TEST(LlvmLibcFenvTest, GetExceptFlagAndSetExceptFlag) {
// 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);
}
diff --git a/libc/test/src/fenv/exception_status_test.cpp b/libc/test/src/fenv/exception_status_test.cpp
index c81dae65b5c27..a7c0164d370de 100644
--- a/libc/test/src/fenv/exception_status_test.cpp
+++ b/libc/test/src/fenv/exception_status_test.cpp
@@ -20,7 +20,7 @@ TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
// 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};
diff --git a/libc/test/src/fenv/feclearexcept_test.cpp b/libc/test/src/fenv/feclearexcept_test.cpp
index 71c7e582bf697..e1cd406bd68f9 100644
--- a/libc/test/src/fenv/feclearexcept_test.cpp
+++ b/libc/test/src/fenv/feclearexcept_test.cpp
@@ -17,28 +17,28 @@
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);
}
}
@@ -46,9 +46,9 @@ TEST(LlvmLibcFEnvTest, ClearTest) {
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);
}
}
}
@@ -58,9 +58,9 @@ TEST(LlvmLibcFEnvTest, ClearTest) {
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);
}
}
}
@@ -72,9 +72,9 @@ TEST(LlvmLibcFEnvTest, ClearTest) {
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);
}
}
}
diff --git a/libc/test/src/fenv/feholdexcept_test.cpp b/libc/test/src/fenv/feholdexcept_test.cpp
index 6bdea80f40373..246650b37bfa1 100644
--- a/libc/test/src/fenv/feholdexcept_test.cpp
+++ b/libc/test/src/fenv/feholdexcept_test.cpp
@@ -24,9 +24,9 @@ TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
// 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)
@@ -35,13 +35,13 @@ TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
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
@@ -51,12 +51,12 @@ TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
// run in a
diff erent 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);
}
}
diff --git a/libc/test/src/fenv/feupdateenv_test.cpp b/libc/test/src/fenv/feupdateenv_test.cpp
index c375340e89229..b6eec583ecfb7 100644
--- a/libc/test/src/fenv/feupdateenv_test.cpp
+++ b/libc/test/src/fenv/feupdateenv_test.cpp
@@ -15,13 +15,13 @@
#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);
}
diff --git a/libc/test/src/fenv/getenv_and_setenv_test.cpp b/libc/test/src/fenv/getenv_and_setenv_test.cpp
index aa1b53d932d15..95cef71c52a8d 100644
--- a/libc/test/src/fenv/getenv_and_setenv_test.cpp
+++ b/libc/test/src/fenv/getenv_and_setenv_test.cpp
@@ -19,49 +19,49 @@
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);
diff --git a/libc/test/src/math/CeilTest.h b/libc/test/src/math/CeilTest.h
index 8c1f0d6d757e4..a45b0d5773560 100644
--- a/libc/test/src/math/CeilTest.h
+++ b/libc/test/src/math/CeilTest.h
@@ -23,10 +23,10 @@ template <typename T> class CeilTest : public __llvm_libc::testing::Test {
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));
}
diff --git a/libc/test/src/math/CopySignTest.h b/libc/test/src/math/CopySignTest.h
index aab7e39841390..46d4c3781184c 100644
--- a/libc/test/src/math/CopySignTest.h
+++ b/libc/test/src/math/CopySignTest.h
@@ -25,11 +25,11 @@ template <typename T> class CopySignTest : public __llvm_libc::testing::Test {
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) {
diff --git a/libc/test/src/math/FAbsTest.h b/libc/test/src/math/FAbsTest.h
index 18c9737fc25ee..d4377f7110da0 100644
--- a/libc/test/src/math/FAbsTest.h
+++ b/libc/test/src/math/FAbsTest.h
@@ -25,10 +25,10 @@ template <typename T> class FAbsTest : public __llvm_libc::testing::Test {
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) {
diff --git a/libc/test/src/math/FDimTest.h b/libc/test/src/math/FDimTest.h
index a0f241fce87f2..029c6390f0767 100644
--- a/libc/test/src/math/FDimTest.h
+++ b/libc/test/src/math/FDimTest.h
@@ -21,35 +21,35 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
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) {
@@ -74,9 +74,9 @@ class FDimTestTemplate : public __llvm_libc::testing::Test {
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());
};
diff --git a/libc/test/src/math/FMaxTest.h b/libc/test/src/math/FMaxTest.h
index 6bdb4c7bd3c90..c72dad5062eb8 100644
--- a/libc/test/src/math/FMaxTest.h
+++ b/libc/test/src/math/FMaxTest.h
@@ -23,7 +23,7 @@ template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
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)));
@@ -32,7 +32,7 @@ template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
}
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)));
@@ -40,11 +40,11 @@ template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
}
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) {
diff --git a/libc/test/src/math/FMinTest.h b/libc/test/src/math/FMinTest.h
index 3f6b258cf837f..a7491a063fd09 100644
--- a/libc/test/src/math/FMinTest.h
+++ b/libc/test/src/math/FMinTest.h
@@ -23,7 +23,7 @@ template <typename T> class FMinTest : public __llvm_libc::testing::Test {
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)));
@@ -32,7 +32,7 @@ template <typename T> class FMinTest : public __llvm_libc::testing::Test {
}
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)));
@@ -40,11 +40,11 @@ template <typename T> class FMinTest : public __llvm_libc::testing::Test {
}
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) {
diff --git a/libc/test/src/math/FloorTest.h b/libc/test/src/math/FloorTest.h
index e0f9015551c82..b52f8a1a43030 100644
--- a/libc/test/src/math/FloorTest.h
+++ b/libc/test/src/math/FloorTest.h
@@ -23,10 +23,10 @@ template <typename T> class FloorTest : public __llvm_libc::testing::Test {
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));
}
diff --git a/libc/test/src/math/FmaTest.h b/libc/test/src/math/FmaTest.h
index a2178e33cd2c6..30af38f3cee3a 100644
--- a/libc/test/src/math/FmaTest.h
+++ b/libc/test/src/math/FmaTest.h
@@ -23,11 +23,11 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
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};
@@ -41,34 +41,34 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
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))),
- v);
+ 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));
@@ -80,9 +80,9 @@ class FmaTestTemplate : public __llvm_libc::testing::Test {
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()));
diff --git a/libc/test/src/math/FrexpTest.h b/libc/test/src/math/FrexpTest.h
index edbcb614b521b..6ccf0b9bac8ac 100644
--- a/libc/test/src/math/FrexpTest.h
+++ b/libc/test/src/math/FrexpTest.h
@@ -20,7 +20,7 @@ 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 *);
@@ -29,7 +29,7 @@ template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
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);
diff --git a/libc/test/src/math/HypotTest.h b/libc/test/src/math/HypotTest.h
index 86326db75cbc8..962da0b39e061 100644
--- a/libc/test/src/math/HypotTest.h
+++ b/libc/test/src/math/HypotTest.h
@@ -25,34 +25,35 @@ class HypotTestTemplate : public __llvm_libc::testing::Test {
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;
@@ -71,10 +72,10 @@ class HypotTestTemplate : public __llvm_libc::testing::Test {
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) {
diff --git a/libc/test/src/math/ILogbTest.h b/libc/test/src/math/ILogbTest.h
index 3aa96bd2c9166..8d8f4e9a6716d 100644
--- a/libc/test/src/math/ILogbTest.h
+++ b/libc/test/src/math/ILogbTest.h
@@ -23,13 +23,13 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
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) {
@@ -76,8 +76,8 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
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)
@@ -93,8 +93,8 @@ class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
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;
diff --git a/libc/test/src/math/LdExpTest.h b/libc/test/src/math/LdExpTest.h
index 3112d97435be4..cd6491d2b71e6 100644
--- a/libc/test/src/math/LdExpTest.h
+++ b/libc/test/src/math/LdExpTest.h
@@ -24,15 +24,15 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -41,9 +41,9 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
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));
}
}
@@ -60,34 +60,34 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
}
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);
}
}
@@ -97,8 +97,8 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
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
@@ -109,32 +109,32 @@ class LdExpTestTemplate : public __llvm_libc::testing::Test {
}
// 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);
}
};
diff --git a/libc/test/src/math/LogbTest.h b/libc/test/src/math/LogbTest.h
index 4d820f6c73222..6e7e6d5bda06e 100644
--- a/libc/test/src/math/LogbTest.h
+++ b/libc/test/src/math/LogbTest.h
@@ -20,7 +20,7 @@ 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);
@@ -28,9 +28,9 @@ template <typename T> class LogbTest : public __llvm_libc::testing::Test {
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) {
diff --git a/libc/test/src/math/ModfTest.h b/libc/test/src/math/ModfTest.h
index 8cc62aafedfbd..a3f0c41082078 100644
--- a/libc/test/src/math/ModfTest.h
+++ b/libc/test/src/math/ModfTest.h
@@ -28,13 +28,13 @@ template <typename T> class ModfTest : public __llvm_libc::testing::Test {
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));
}
diff --git a/libc/test/src/math/NextAfterTest.h b/libc/test/src/math/NextAfterTest.h
index 73eb601bf619d..4b7b5f4997ee4 100644
--- a/libc/test/src/math/NextAfterTest.h
+++ b/libc/test/src/math/NextAfterTest.h
@@ -23,17 +23,17 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -44,10 +44,10 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
}
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;
@@ -59,7 +59,7 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -71,68 +71,68 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -142,46 +142,48 @@ class NextAfterTestTemplate : public __llvm_libc::testing::Test {
// '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));
}
};
diff --git a/libc/test/src/math/RIntTest.h b/libc/test/src/math/RIntTest.h
index dbe2fe3a50823..53844a1eaa5fe 100644
--- a/libc/test/src/math/RIntTest.h
+++ b/libc/test/src/math/RIntTest.h
@@ -34,10 +34,10 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
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) {
@@ -57,18 +57,18 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
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));
@@ -81,7 +81,7 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
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));
@@ -95,12 +95,12 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
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));
}
@@ -109,8 +109,8 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
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.
@@ -119,7 +119,7 @@ class RIntTestTemplate : public __llvm_libc::testing::Test {
}
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));
}
diff --git a/libc/test/src/math/RemQuoTest.h b/libc/test/src/math/RemQuoTest.h
index ce77be1535c98..e96ddd759bd6b 100644
--- a/libc/test/src/math/RemQuoTest.h
+++ b/libc/test/src/math/RemQuoTest.h
@@ -24,10 +24,10 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
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 *);
@@ -39,13 +39,13 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
y = T(1.0);
x = inf;
EXPECT_FP_EQ(nan, func(x, y, "ient));
- x = negInf;
+ x = neg_inf;
EXPECT_FP_EQ(nan, func(x, y, "ient));
x = T(1.0);
y = zero;
EXPECT_FP_EQ(nan, func(x, y, "ient));
- y = negZero;
+ y = neg_zero;
EXPECT_FP_EQ(nan, func(x, y, "ient));
y = nan;
@@ -64,9 +64,9 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
y = T(1.0);
EXPECT_FP_EQ(func(x, y, "ient), zero);
- x = negZero;
+ x = neg_zero;
y = T(1.0);
- EXPECT_FP_EQ(func(x, y, "ient), negZero);
+ EXPECT_FP_EQ(func(x, y, "ient), neg_zero);
x = T(1.125);
y = inf;
@@ -87,19 +87,19 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
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;
@@ -111,9 +111,9 @@ class RemQuoTestTemplate : public __llvm_libc::testing::Test {
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;
diff --git a/libc/test/src/math/RoundTest.h b/libc/test/src/math/RoundTest.h
index 928268e719a19..d4fea629507fe 100644
--- a/libc/test/src/math/RoundTest.h
+++ b/libc/test/src/math/RoundTest.h
@@ -23,10 +23,10 @@ template <typename T> class RoundTest : public __llvm_libc::testing::Test {
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));
}
diff --git a/libc/test/src/math/RoundToIntegerTest.h b/libc/test/src/math/RoundToIntegerTest.h
index 7dd340b067192..b77c4bffc8284 100644
--- a/libc/test/src/math/RoundToIntegerTest.h
+++ b/libc/test/src/math/RoundToIntegerTest.h
@@ -36,10 +36,10 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -49,21 +49,21 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -92,20 +92,20 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
// 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 {
@@ -115,7 +115,7 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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);
@@ -135,9 +135,9 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
// 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;
@@ -149,7 +149,7 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
void testRoundNumbers(RoundToIntegerFunc func) {
if (TestModes) {
for (int mode : roundingModes) {
- __llvm_libc::fputil::setRound(mode);
+ __llvm_libc::fputil::set_round(mode);
doRoundNumbersTest(func);
}
} else {
@@ -176,7 +176,7 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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 {
@@ -199,14 +199,15 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
// 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);
@@ -224,8 +225,8 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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))
@@ -233,22 +234,22 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
// 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 {
@@ -267,8 +268,8 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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.
@@ -282,7 +283,7 @@ class RoundToIntegerTestTemplate : public __llvm_libc::testing::Test {
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
diff --git a/libc/test/src/math/SqrtTest.h b/libc/test/src/math/SqrtTest.h
index 02aeb42f1ad8c..a6120a2c51eb0 100644
--- a/libc/test/src/math/SqrtTest.h
+++ b/libc/test/src/math/SqrtTest.h
@@ -19,7 +19,7 @@ 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);
@@ -27,7 +27,7 @@ template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
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)));
@@ -39,7 +39,7 @@ template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
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));
diff --git a/libc/test/src/math/TruncTest.h b/libc/test/src/math/TruncTest.h
index 9f4ff50bebd18..6e65f3d7888df 100644
--- a/libc/test/src/math/TruncTest.h
+++ b/libc/test/src/math/TruncTest.h
@@ -23,10 +23,10 @@ template <typename T> class TruncTest : public __llvm_libc::testing::Test {
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));
}
diff --git a/libc/test/src/math/cosf_test.cpp b/libc/test/src/math/cosf_test.cpp
index 92f193b50c751..be968d6ea35c3 100644
--- a/libc/test/src/math/cosf_test.cpp
+++ b/libc/test/src/math/cosf_test.cpp
@@ -42,7 +42,7 @@ TEST(LlvmLibcCosfTest, SpecialNumbers) {
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);
}
diff --git a/libc/test/src/math/exhaustive/expm1f_test.cpp b/libc/test/src/math/exhaustive/expm1f_test.cpp
index 46be2ab371fa1..5b277342a6521 100644
--- a/libc/test/src/math/exhaustive/expm1f_test.cpp
+++ b/libc/test/src/math/exhaustive/expm1f_test.cpp
@@ -20,7 +20,7 @@ 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);
}
diff --git a/libc/test/src/math/exp2f_test.cpp b/libc/test/src/math/exp2f_test.cpp
index 16811fb664a6b..7db1a576f5542 100644
--- a/libc/test/src/math/exp2f_test.cpp
+++ b/libc/test/src/math/exp2f_test.cpp
@@ -29,7 +29,7 @@ TEST(LlvmLibcExp2fTest, SpecialNumbers) {
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));
diff --git a/libc/test/src/math/expf_test.cpp b/libc/test/src/math/expf_test.cpp
index b06b560a70852..68d7dff462f55 100644
--- a/libc/test/src/math/expf_test.cpp
+++ b/libc/test/src/math/expf_test.cpp
@@ -29,7 +29,7 @@ TEST(LlvmLibcExpfTest, SpecialNumbers) {
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));
diff --git a/libc/test/src/math/expm1f_test.cpp b/libc/test/src/math/expm1f_test.cpp
index 523b1951ad117..8f83790bde5e0 100644
--- a/libc/test/src/math/expm1f_test.cpp
+++ b/libc/test/src/math/expm1f_test.cpp
@@ -29,7 +29,7 @@ TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
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));
diff --git a/libc/test/src/math/sincosf_test.cpp b/libc/test/src/math/sincosf_test.cpp
index 7812fbe6d9c34..886fc1e7dcacd 100644
--- a/libc/test/src/math/sincosf_test.cpp
+++ b/libc/test/src/math/sincosf_test.cpp
@@ -51,7 +51,7 @@ TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
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);
diff --git a/libc/test/src/math/sinf_test.cpp b/libc/test/src/math/sinf_test.cpp
index 6770e47f6da3e..64d932ee22f10 100644
--- a/libc/test/src/math/sinf_test.cpp
+++ b/libc/test/src/math/sinf_test.cpp
@@ -42,7 +42,7 @@ TEST(LlvmLibcSinfTest, SpecialNumbers) {
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);
}
diff --git a/libc/test/src/stdlib/atof_test.cpp b/libc/test/src/stdlib/atof_test.cpp
index e5de03f72cd3c..a5379b2ee6666 100644
--- a/libc/test/src/stdlib/atof_test.cpp
+++ b/libc/test/src/stdlib/atof_test.cpp
@@ -28,9 +28,9 @@ TEST(LlvmLibcAToFTest, SimpleTest) {
__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);
}
@@ -45,8 +45,8 @@ TEST(LlvmLibcAToFTest, FailedParsingTest) {
__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);
}
diff --git a/libc/test/src/stdlib/strtod_test.cpp b/libc/test/src/stdlib/strtod_test.cpp
index 48c960d06e0cb..154cf1a33e7e7 100644
--- a/libc/test/src/stdlib/strtod_test.cpp
+++ b/libc/test/src/stdlib/strtod_test.cpp
@@ -47,9 +47,9 @@ class LlvmLibcStrToDTest : public __llvm_libc::testing::Test {
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);
}
};
diff --git a/libc/test/src/stdlib/strtof_test.cpp b/libc/test/src/stdlib/strtof_test.cpp
index 88e7623503adf..db6c194904db5 100644
--- a/libc/test/src/stdlib/strtof_test.cpp
+++ b/libc/test/src/stdlib/strtof_test.cpp
@@ -47,9 +47,9 @@ class LlvmLibcStrToFTest : public __llvm_libc::testing::Test {
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);
}
};
diff --git a/libc/test/src/string/memory_utils/elements_test.cpp b/libc/test/src/string/memory_utils/elements_test.cpp
index 3c269acb28859..ce9a67d81f312 100644
--- a/libc/test/src/string/memory_utils/elements_test.cpp
+++ b/libc/test/src/string/memory_utils/elements_test.cpp
@@ -56,7 +56,7 @@ void Randomize(cpp::MutableArrayRef<char> 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;
@@ -64,15 +64,15 @@ template <typename Element> Buffer<Element> GetRandomBuffer() {
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];
@@ -80,47 +80,47 @@ template <typename T> T Copy(const T &Input) {
}
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);
}
}
@@ -128,8 +128,8 @@ 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);
}
}
diff --git a/libc/test/src/string/memory_utils/memory_access_test.cpp b/libc/test/src/string/memory_utils/memory_access_test.cpp
index 966863d724b56..e107d6fd4f9b1 100644
--- a/libc/test/src/string/memory_utils/memory_access_test.cpp
+++ b/libc/test/src/string/memory_utils/memory_access_test.cpp
@@ -73,27 +73,27 @@ struct MemoryAccessObserver {
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);
}
};
@@ -112,25 +112,26 @@ struct LlvmLibcTestAccessBase : public testing::Test {
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);
@@ -165,7 +166,7 @@ struct LlvmLibcTestAccessTail : public LlvmLibcTestAccessBase {
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);
@@ -179,8 +180,8 @@ struct LlvmLibcTestAccessHeadTail : public LlvmLibcTestAccessBase {
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);
@@ -194,9 +195,9 @@ struct LlvmLibcTestAccessLoop : public LlvmLibcTestAccessBase {
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);
@@ -212,9 +213,9 @@ struct LlvmLibcTestAccessAlignedAccess : public LlvmLibcTestAccessBase {
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,
diff --git a/libc/test/src/time/TmHelper.h b/libc/test/src/time/TmHelper.h
index 6a0b3edac55ea..1ab2a5eeeba6e 100644
--- a/libc/test/src/time/TmHelper.h
+++ b/libc/test/src/time/TmHelper.h
@@ -29,7 +29,7 @@ static inline void InitializeTmData(struct tm *tm_data, int year, int month,
.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;
diff --git a/libc/test/src/time/asctime_r_test.cpp b/libc/test/src/time/asctime_r_test.cpp
index 66db4413d3d5d..1f883cf0cac14 100644
--- a/libc/test/src/time/asctime_r_test.cpp
+++ b/libc/test/src/time/asctime_r_test.cpp
@@ -30,7 +30,7 @@ TEST(LlvmLibcAsctimeR, 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);
@@ -42,7 +42,7 @@ TEST(LlvmLibcAsctimeR, Nullptr) {
}
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.
diff --git a/libc/test/src/time/gmtime_r_test.cpp b/libc/test/src/time/gmtime_r_test.cpp
index 037460c050c74..b6556702ab56d 100644
--- a/libc/test/src/time/gmtime_r_test.cpp
+++ b/libc/test/src/time/gmtime_r_test.cpp
@@ -27,9 +27,9 @@ TEST(LlvmLibcGmTimeR, EndOf32BitEpochYear) {
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);
@@ -48,9 +48,9 @@ TEST(LlvmLibcGmTimeR, Max64BitYear) {
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);
diff --git a/libc/test/src/time/gmtime_test.cpp b/libc/test/src/time/gmtime_test.cpp
index ba24d1f82aca6..b7b2707849b90 100644
--- a/libc/test/src/time/gmtime_test.cpp
+++ b/libc/test/src/time/gmtime_test.cpp
@@ -21,16 +21,17 @@ 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) -
- 1;
+ 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);
@@ -47,9 +48,9 @@ TEST(LlvmLibcGmTime, InvalidSeconds) {
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.
@@ -60,9 +61,9 @@ TEST(LlvmLibcGmTime, InvalidSeconds) {
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);
}
@@ -71,29 +72,29 @@ 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);
}
@@ -102,29 +103,29 @@ 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);
}
@@ -132,16 +133,16 @@ TEST(LlvmLibcGmTime, InvalidHours) {
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);
}
@@ -150,29 +151,30 @@ 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);
}
@@ -181,59 +183,59 @@ 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);
}
@@ -248,9 +250,9 @@ TEST(LlvmLibcGmTime, EndOf32BitEpochYear) {
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);
}
@@ -266,9 +268,9 @@ TEST(LlvmLibcGmTime, Max64BitYear) {
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);
@@ -280,9 +282,9 @@ TEST(LlvmLibcGmTime, Max64BitYear) {
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);
}
diff --git a/libc/test/src/time/mktime_test.cpp b/libc/test/src/time/mktime_test.cpp
index b9ea4ed64c0d1..d08a6b9640dde 100644
--- a/libc/test/src/time/mktime_test.cpp
+++ b/libc/test/src/time/mktime_test.cpp
@@ -54,9 +54,9 @@ TEST(LlvmLibcMkTime, InvalidSeconds) {
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.
@@ -75,9 +75,9 @@ TEST(LlvmLibcMkTime, InvalidSeconds) {
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);
}
@@ -94,15 +94,15 @@ TEST(LlvmLibcMkTime, InvalidMinutes) {
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.
@@ -115,15 +115,15 @@ TEST(LlvmLibcMkTime, InvalidMinutes) {
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);
}
@@ -140,15 +140,15 @@ TEST(LlvmLibcMkTime, InvalidHours) {
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.
@@ -161,15 +161,15 @@ TEST(LlvmLibcMkTime, InvalidHours) {
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);
}
@@ -186,16 +186,16 @@ TEST(LlvmLibcMkTime, InvalidYear) {
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);
}
@@ -206,22 +206,22 @@ TEST(LlvmLibcMkTime, InvalidEndOf32BitEpochYear) {
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) {
@@ -236,15 +236,15 @@ TEST(LlvmLibcMkTime, InvalidMonths) {
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.
@@ -257,16 +257,16 @@ TEST(LlvmLibcMkTime, InvalidMonths) {
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);
}
@@ -283,15 +283,15 @@ TEST(LlvmLibcMkTime, InvalidDays) {
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);
@@ -305,15 +305,15 @@ TEST(LlvmLibcMkTime, InvalidDays) {
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);
@@ -327,15 +327,15 @@ TEST(LlvmLibcMkTime, InvalidDays) {
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);
@@ -349,16 +349,16 @@ TEST(LlvmLibcMkTime, InvalidDays) {
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);
}
@@ -382,9 +382,9 @@ TEST(LlvmLibcMkTime, EndOf32BitEpochYear) {
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);
}
@@ -409,9 +409,9 @@ TEST(LlvmLibcMkTime, Max64BitYear) {
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);
@@ -423,9 +423,9 @@ TEST(LlvmLibcMkTime, Max64BitYear) {
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);
}
diff --git a/libc/test/utils/FPUtil/x86_long_double_test.cpp b/libc/test/utils/FPUtil/x86_long_double_test.cpp
index 94c75e8acdef8..9555a03413822 100644
--- a/libc/test/utils/FPUtil/x86_long_double_test.cpp
+++ b/libc/test/utils/FPUtil/x86_long_double_test.cpp
@@ -13,7 +13,7 @@
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
@@ -21,14 +21,14 @@ TEST(X86LongDoubleTest, isNaN) {
// 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;
@@ -39,7 +39,7 @@ TEST(X86LongDoubleTest, isNaN) {
bits.mantissa = i;
long double nan = bits;
ASSERT_NE(isnan(nan), 0);
- ASSERT_TRUE(bits.isNaN());
+ ASSERT_TRUE(bits.is_nan());
}
bits.exponent = 1;
@@ -50,7 +50,7 @@ TEST(X86LongDoubleTest, isNaN) {
bits.mantissa = i;
long double nan = bits;
ASSERT_NE(isnan(nan), 0);
- ASSERT_TRUE(bits.isNaN());
+ ASSERT_TRUE(bits.is_nan());
}
bits.exponent = 1;
@@ -61,7 +61,7 @@ TEST(X86LongDoubleTest, isNaN) {
bits.mantissa = i;
long double valid = bits;
ASSERT_EQ(isnan(valid), 0);
- ASSERT_FALSE(bits.isNaN());
+ ASSERT_FALSE(bits.is_nan());
}
bits.exponent = 0;
@@ -71,7 +71,7 @@ TEST(X86LongDoubleTest, isNaN) {
bits.mantissa = i;
long double valid = bits;
ASSERT_EQ(isnan(valid), 0);
- ASSERT_FALSE(bits.isNaN());
+ ASSERT_FALSE(bits.is_nan());
}
bits.exponent = 0;
@@ -81,6 +81,6 @@ TEST(X86LongDoubleTest, isNaN) {
bits.mantissa = i;
long double valid = bits;
ASSERT_EQ(isnan(valid), 0);
- ASSERT_FALSE(bits.isNaN());
+ ASSERT_FALSE(bits.is_nan());
}
}
diff --git a/libc/utils/MPFRWrapper/MPFRUtils.cpp b/libc/utils/MPFRWrapper/MPFRUtils.cpp
index 0b2b1c0dbd5bd..366ca02f69e4b 100644
--- a/libc/utils/MPFRWrapper/MPFRUtils.cpp
+++ b/libc/utils/MPFRWrapper/MPFRUtils.cpp
@@ -310,12 +310,12 @@ class MPFRNumber {
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) {
@@ -323,7 +323,7 @@ class MPFRNumber {
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>();
}
@@ -335,12 +335,12 @@ class MPFRNumber {
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);
@@ -351,12 +351,12 @@ class MPFRNumber {
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);
diff --git a/libc/utils/UnitTest/FPMatcher.cpp b/libc/utils/UnitTest/FPMatcher.cpp
index 8f19f11d382b0..c86473e61a2a8 100644
--- a/libc/utils/UnitTest/FPMatcher.cpp
+++ b/libc/utils/UnitTest/FPMatcher.cpp
@@ -37,27 +37,27 @@ describeValue(const char *label, ValType value,
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';
diff --git a/libc/utils/UnitTest/FPMatcher.h b/libc/utils/UnitTest/FPMatcher.h
index ff383d56868f9..7f1c75d7e108c 100644
--- a/libc/utils/UnitTest/FPMatcher.h
+++ b/libc/utils/UnitTest/FPMatcher.h
@@ -40,13 +40,13 @@ class FPMatcher : public __llvm_libc::testing::Matcher<T> {
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());
}
@@ -69,10 +69,10 @@ FPMatcher<T, C> getMatcher(T expectedValue) {
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( \
More information about the libc-commits
mailing list