[libc-commits] [libc] 6363320 - [libc][NFC] Another round of replacement of static inline with LIBC_INLINE.
Siva Chandra Reddy via libc-commits
libc-commits at lists.llvm.org
Mon Jan 23 16:37:17 PST 2023
Author: Siva Chandra Reddy
Date: 2023-01-24T00:37:09Z
New Revision: 6363320ba6beeb7a014163aeb5a53b3ad362d844
URL: https://github.com/llvm/llvm-project/commit/6363320ba6beeb7a014163aeb5a53b3ad362d844
DIFF: https://github.com/llvm/llvm-project/commit/6363320ba6beeb7a014163aeb5a53b3ad362d844.diff
LOG: [libc][NFC] Another round of replacement of static inline with LIBC_INLINE.
Reviewed By: lntue
Differential Revision: https://reviews.llvm.org/D142398
Added:
Modified:
libc/src/__support/FPUtil/FPBits.h
libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
libc/src/math/generic/CMakeLists.txt
libc/src/math/generic/explogxf.h
libc/src/math/generic/inv_trigf_utils.h
libc/src/math/generic/math_utils.h
libc/src/math/generic/range_reduction.h
libc/src/math/generic/range_reduction_fma.h
libc/src/math/generic/sincosf_utils.h
libc/src/pthread/CMakeLists.txt
libc/src/pthread/pthread_mutexattr.h
libc/src/signal/linux/signal_utils.h
libc/src/string/CMakeLists.txt
libc/src/string/memory_utils/README.md
libc/src/string/memory_utils/bzero_implementations.h
libc/src/string/memory_utils/memset_implementations.h
libc/src/string/memory_utils/op_aarch64.h
libc/src/string/memory_utils/op_builtin.h
libc/src/string/memory_utils/op_generic.h
libc/src/string/memory_utils/op_x86.h
libc/src/string/memory_utils/utils.h
libc/src/string/string_utils.h
libc/src/time/time_utils.h
utils/bazel/llvm-project-overlay/libc/BUILD.bazel
Removed:
################################################################################
diff --git a/libc/src/__support/FPUtil/FPBits.h b/libc/src/__support/FPUtil/FPBits.h
index fd62a790585c8..b69ee190e6c45 100644
--- a/libc/src/__support/FPUtil/FPBits.h
+++ b/libc/src/__support/FPUtil/FPBits.h
@@ -51,41 +51,45 @@ template <typename T> struct FPBits {
UIntType bits;
- void set_mantissa(UIntType mantVal) {
+ LIBC_INLINE void set_mantissa(UIntType mantVal) {
mantVal &= (FloatProp::MANTISSA_MASK);
bits &= ~(FloatProp::MANTISSA_MASK);
bits |= mantVal;
}
- UIntType get_mantissa() const { return bits & FloatProp::MANTISSA_MASK; }
+ LIBC_INLINE UIntType get_mantissa() const {
+ return bits & FloatProp::MANTISSA_MASK;
+ }
- void set_unbiased_exponent(UIntType expVal) {
+ LIBC_INLINE void set_unbiased_exponent(UIntType expVal) {
expVal = (expVal << (FloatProp::MANTISSA_WIDTH)) & FloatProp::EXPONENT_MASK;
bits &= ~(FloatProp::EXPONENT_MASK);
bits |= expVal;
}
- uint16_t get_unbiased_exponent() const {
+ LIBC_INLINE uint16_t get_unbiased_exponent() const {
return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
(FloatProp::MANTISSA_WIDTH));
}
// The function return mantissa with the implicit bit set iff the current
// value is a valid normal number.
- constexpr UIntType get_explicit_mantissa() {
+ LIBC_INLINE constexpr UIntType get_explicit_mantissa() {
return ((get_unbiased_exponent() > 0 && !is_inf_or_nan())
? (FloatProp::MANTISSA_MASK + 1)
: 0) |
(FloatProp::MANTISSA_MASK & bits);
}
- void set_sign(bool signVal) {
+ LIBC_INLINE void set_sign(bool signVal) {
bits |= FloatProp::SIGN_MASK;
if (!signVal)
bits -= FloatProp::SIGN_MASK;
}
- bool get_sign() const { return (bits & FloatProp::SIGN_MASK) != 0; }
+ LIBC_INLINE bool get_sign() const {
+ return (bits & FloatProp::SIGN_MASK) != 0;
+ }
static_assert(sizeof(T) == sizeof(UIntType),
"Data type and integral representation have
diff erent sizes.");
@@ -112,65 +116,65 @@ template <typename T> struct FPBits {
FPBits() : bits(0) {}
- T get_val() const { return cpp::bit_cast<T>(bits); }
+ LIBC_INLINE T get_val() const { return cpp::bit_cast<T>(bits); }
- void set_val(T value) { bits = cpp::bit_cast<UIntType>(value); }
+ LIBC_INLINE void set_val(T value) { bits = cpp::bit_cast<UIntType>(value); }
- explicit operator T() const { return get_val(); }
+ LIBC_INLINE explicit operator T() const { return get_val(); }
- UIntType uintval() const { return bits; }
+ LIBC_INLINE UIntType uintval() const { return bits; }
- int get_exponent() const {
+ LIBC_INLINE int get_exponent() const {
return int(get_unbiased_exponent()) - EXPONENT_BIAS;
}
- bool is_zero() const {
+ LIBC_INLINE bool is_zero() const {
// Remove sign bit by shift
return (bits << 1) == 0;
}
- bool is_inf() const {
+ LIBC_INLINE bool is_inf() const {
return (bits & FloatProp::EXP_MANT_MASK) == FloatProp::EXPONENT_MASK;
}
- bool is_nan() const {
+ LIBC_INLINE bool is_nan() const {
return (bits & FloatProp::EXP_MANT_MASK) > FloatProp::EXPONENT_MASK;
}
- bool is_quiet_nan() const {
+ LIBC_INLINE bool is_quiet_nan() const {
return (bits & FloatProp::EXP_MANT_MASK) ==
(FloatProp::EXPONENT_MASK | FloatProp::QUIET_NAN_MASK);
}
- bool is_inf_or_nan() const {
+ LIBC_INLINE bool is_inf_or_nan() const {
return (bits & FloatProp::EXPONENT_MASK) == FloatProp::EXPONENT_MASK;
}
- static constexpr FPBits<T> zero(bool sign = false) {
+ LIBC_INLINE static constexpr FPBits<T> zero(bool sign = false) {
return FPBits(sign ? FloatProp::SIGN_MASK : UIntType(0));
}
- static constexpr FPBits<T> neg_zero() { return zero(true); }
+ LIBC_INLINE static constexpr FPBits<T> neg_zero() { return zero(true); }
- static constexpr FPBits<T> inf(bool sign = false) {
+ LIBC_INLINE static constexpr FPBits<T> inf(bool sign = false) {
FPBits<T> bits(sign ? FloatProp::SIGN_MASK : UIntType(0));
bits.set_unbiased_exponent(MAX_EXPONENT);
return bits;
}
- static constexpr FPBits<T> neg_inf() {
+ LIBC_INLINE static constexpr FPBits<T> neg_inf() {
FPBits<T> bits = inf();
bits.set_sign(1);
return bits;
}
- static constexpr T build_nan(UIntType v) {
+ LIBC_INLINE static constexpr T build_nan(UIntType v) {
FPBits<T> bits = inf();
bits.set_mantissa(v);
return T(bits);
}
- static constexpr T build_quiet_nan(UIntType v) {
+ LIBC_INLINE static constexpr T build_quiet_nan(UIntType v) {
return build_nan(FloatProp::QUIET_NAN_MASK | v);
}
@@ -184,7 +188,7 @@ template <typename T> struct FPBits {
// 3) The function did not check exponent high limit.
// 4) "number" zero value is not processed correctly.
// 5) Number is unsigned, so the result can be only positive.
- inline static constexpr FPBits<T> make_value(UIntType number, int ep) {
+ LIBC_INLINE static constexpr FPBits<T> make_value(UIntType number, int ep) {
FPBits<T> result;
// offset: +1 for sign, but -1 for implicit first bit
int lz = unsafe_clz(number) - FloatProp::EXPONENT_WIDTH;
@@ -201,8 +205,8 @@ template <typename T> struct FPBits {
return result;
}
- inline static FPBits<T> create_value(bool sign, UIntType unbiased_exp,
- UIntType mantissa) {
+ LIBC_INLINE static FPBits<T> create_value(bool sign, UIntType unbiased_exp,
+ UIntType mantissa) {
FPBits<T> result;
result.set_sign(sign);
result.set_unbiased_exponent(unbiased_exp);
diff --git a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
index 57e1923795bfc..2c49a485073c0 100644
--- a/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
+++ b/libc/src/__support/FPUtil/x86_64/LongDoubleBits.h
@@ -12,6 +12,7 @@
#include "src/__support/CPP/bit.h"
#include "src/__support/UInt128.h"
#include "src/__support/architectures.h"
+#include "src/__support/common.h"
#if !defined(LLVM_LIBC_ARCH_X86)
#error "Invalid include"
@@ -52,19 +53,21 @@ template <> struct FPBits<long double> {
UIntType bits;
- void set_mantissa(UIntType mantVal) {
+ LIBC_INLINE void set_mantissa(UIntType mantVal) {
mantVal &= (FloatProp::MANTISSA_MASK);
bits &= ~(FloatProp::MANTISSA_MASK);
bits |= mantVal;
}
- UIntType get_mantissa() const { return bits & FloatProp::MANTISSA_MASK; }
+ LIBC_INLINE UIntType get_mantissa() const {
+ return bits & FloatProp::MANTISSA_MASK;
+ }
- UIntType get_explicit_mantissa() const {
+ LIBC_INLINE UIntType get_explicit_mantissa() const {
return bits & (FloatProp::MANTISSA_MASK | FloatProp::EXPLICIT_BIT_MASK);
}
- void set_unbiased_exponent(UIntType expVal) {
+ LIBC_INLINE void set_unbiased_exponent(UIntType expVal) {
expVal =
(expVal << (FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH)) &
FloatProp::EXPONENT_MASK;
@@ -72,28 +75,28 @@ template <> struct FPBits<long double> {
bits |= expVal;
}
- uint16_t get_unbiased_exponent() const {
+ LIBC_INLINE uint16_t get_unbiased_exponent() const {
return uint16_t((bits & FloatProp::EXPONENT_MASK) >>
(FloatProp::BIT_WIDTH - 1 - FloatProp::EXPONENT_WIDTH));
}
- void set_implicit_bit(bool implicitVal) {
+ LIBC_INLINE void set_implicit_bit(bool implicitVal) {
bits &= ~(UIntType(1) << FloatProp::MANTISSA_WIDTH);
bits |= (UIntType(implicitVal) << FloatProp::MANTISSA_WIDTH);
}
- bool get_implicit_bit() const {
+ LIBC_INLINE bool get_implicit_bit() const {
return ((bits & (UIntType(1) << FloatProp::MANTISSA_WIDTH)) >>
FloatProp::MANTISSA_WIDTH);
}
- void set_sign(bool signVal) {
+ LIBC_INLINE void set_sign(bool signVal) {
bits &= ~(FloatProp::SIGN_MASK);
UIntType sign1 = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
bits |= sign1;
}
- bool get_sign() const {
+ LIBC_INLINE bool get_sign() const {
return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
}
@@ -111,9 +114,11 @@ template <> struct FPBits<long double> {
cpp::enable_if_t<cpp::is_same_v<XType, UIntType>, int> = 0>
explicit FPBits(XType x) : bits(x) {}
- operator long double() { return cpp::bit_cast<long double>(bits); }
+ LIBC_INLINE operator long double() {
+ return cpp::bit_cast<long double>(bits);
+ }
- UIntType uintval() {
+ LIBC_INLINE UIntType uintval() {
// We zero the padding bits as they can contain garbage.
static constexpr UIntType MASK =
(UIntType(1) << (sizeof(long double) * 8 -
@@ -122,23 +127,23 @@ template <> struct FPBits<long double> {
return bits & MASK;
}
- int get_exponent() const {
+ LIBC_INLINE int get_exponent() const {
if (get_unbiased_exponent() == 0)
return int(1) - EXPONENT_BIAS;
return int(get_unbiased_exponent()) - EXPONENT_BIAS;
}
- bool is_zero() const {
+ LIBC_INLINE bool is_zero() const {
return get_unbiased_exponent() == 0 && get_mantissa() == 0 &&
get_implicit_bit() == 0;
}
- bool is_inf() const {
+ LIBC_INLINE bool is_inf() const {
return get_unbiased_exponent() == MAX_EXPONENT && get_mantissa() == 0 &&
get_implicit_bit() == 1;
}
- bool is_nan() const {
+ LIBC_INLINE bool is_nan() const {
if (get_unbiased_exponent() == MAX_EXPONENT) {
return (get_implicit_bit() == 0) || get_mantissa() != 0;
} else if (get_unbiased_exponent() != 0) {
@@ -147,29 +152,31 @@ template <> struct FPBits<long double> {
return false;
}
- bool is_inf_or_nan() const {
+ LIBC_INLINE 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); }
+ LIBC_INLINE static FPBits<long double> zero() {
+ return FPBits<long double>(0.0l);
+ }
- static FPBits<long double> neg_zero() {
+ LIBC_INLINE static FPBits<long double> neg_zero() {
FPBits<long double> bits(0.0l);
bits.set_sign(1);
return bits;
}
- static FPBits<long double> inf() {
+ LIBC_INLINE static FPBits<long double> inf() {
FPBits<long double> bits(0.0l);
bits.set_unbiased_exponent(MAX_EXPONENT);
bits.set_implicit_bit(1);
return bits;
}
- static FPBits<long double> neg_inf() {
+ LIBC_INLINE static FPBits<long double> neg_inf() {
FPBits<long double> bits(0.0l);
bits.set_unbiased_exponent(MAX_EXPONENT);
bits.set_implicit_bit(1);
@@ -177,7 +184,7 @@ template <> struct FPBits<long double> {
return bits;
}
- static long double build_nan(UIntType v) {
+ LIBC_INLINE static long double build_nan(UIntType v) {
FPBits<long double> bits(0.0l);
bits.set_unbiased_exponent(MAX_EXPONENT);
bits.set_implicit_bit(1);
@@ -185,11 +192,11 @@ template <> struct FPBits<long double> {
return bits;
}
- static long double build_quiet_nan(UIntType v) {
+ LIBC_INLINE static long double build_quiet_nan(UIntType v) {
return build_nan(FloatProp::QUIET_NAN_MASK | v);
}
- inline static FPBits<long double>
+ LIBC_INLINE static FPBits<long double>
create_value(bool sign, UIntType unbiased_exp, UIntType mantissa) {
FPBits<long double> result;
result.set_sign(sign);
diff --git a/libc/src/math/generic/CMakeLists.txt b/libc/src/math/generic/CMakeLists.txt
index 512ed270200fb..dd4b07ed97b4f 100644
--- a/libc/src/math/generic/CMakeLists.txt
+++ b/libc/src/math/generic/CMakeLists.txt
@@ -56,6 +56,7 @@ add_header_library(
libc.src.__support.FPUtil.fma
libc.src.__support.FPUtil.multiply_add
libc.src.__support.FPUtil.nearest_integer
+ libc.src.__support.common
)
add_header_library(
@@ -66,6 +67,7 @@ add_header_library(
.range_reduction
libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.polyeval
+ libc.src.__support.common
)
add_entrypoint_object(
@@ -1246,6 +1248,7 @@ add_object_library(
libc.src.__support.FPUtil.multiply_add
libc.src.__support.FPUtil.nearest_integer
libc.src.__support.FPUtil.polyeval
+ libc.src.__support.common
libc.include.errno
libc.src.errno.errno
libc.include.math
@@ -1319,6 +1322,7 @@ add_object_library(
libc.src.__support.FPUtil.nearest_integer
libc.src.__support.FPUtil.nearest_integer_operations
libc.src.__support.FPUtil.polyeval
+ libc.src.__support.common
libc.include.errno
libc.src.errno.errno
libc.include.math
diff --git a/libc/src/math/generic/explogxf.h b/libc/src/math/generic/explogxf.h
index e60c0d5c34793..cce96172cf0ea 100644
--- a/libc/src/math/generic/explogxf.h
+++ b/libc/src/math/generic/explogxf.h
@@ -56,7 +56,7 @@ struct ExpBase {
0x1.ffffffffe5bc8p-2, 0x1.555555555cd67p-3, 0x1.5555c2a9b48b4p-5,
0x1.11112a0e34bdbp-7};
- static double powb_lo(double dx) {
+ LIBC_INLINE static double powb_lo(double dx) {
using fputil::multiply_add;
double dx2 = dx * dx;
double c0 = 1.0 + dx;
@@ -150,7 +150,7 @@ struct exp_b_reduc_t {
// - EXP_2_MID : look up table for bit fields of 2^mid
// Return:
// { 2^(hi + mid), lo }
-template <class Base> static inline exp_b_reduc_t exp_b_range_reduc(float x) {
+template <class Base> LIBC_INLINE exp_b_reduc_t exp_b_range_reduc(float x) {
double xd = static_cast<double>(x);
// kd = round((hi + mid) * log2(b) * 2^MID_BITS)
double kd = fputil::nearest_integer(Base::LOG2_B * xd);
@@ -207,7 +207,7 @@ template <class Base> static inline exp_b_reduc_t exp_b_range_reduc(float x) {
// The main point of these formulas is that the expensive part of calculating
// the polynomials approximating lower parts of e^(x) and e^(-x) are shared
// and only done once.
-template <bool is_sinh> static inline double exp_pm_eval(float x) {
+template <bool is_sinh> LIBC_INLINE double exp_pm_eval(float x) {
double xd = static_cast<double>(x);
// round(x * log2(e) * 2^5)
@@ -259,7 +259,7 @@ template <bool is_sinh> static inline double exp_pm_eval(float x) {
}
// x should be positive, normal finite value
-inline static double log2_eval(double x) {
+LIBC_INLINE static double log2_eval(double x) {
using FPB = fputil::FPBits<double>;
FPB bs(x);
@@ -287,7 +287,7 @@ inline static double log2_eval(double x) {
}
// x should be positive, normal finite value
-inline static double log_eval(double x) {
+LIBC_INLINE static double log_eval(double x) {
// ln(x) = log[2,x] * ln(2)
return log2_eval(x) * 0x1.62e42fefa39efp-1;
}
diff --git a/libc/src/math/generic/inv_trigf_utils.h b/libc/src/math/generic/inv_trigf_utils.h
index 202a4a6be5b16..a01db3ab8e7bd 100644
--- a/libc/src/math/generic/inv_trigf_utils.h
+++ b/libc/src/math/generic/inv_trigf_utils.h
@@ -37,7 +37,7 @@ extern const double ATAN_K[5];
// atan(u) + atan(v) = atan((u+v)/(1-uv))
// x should be positive, normal finite value
-static inline double atan_eval(double x) {
+LIBC_INLINE double atan_eval(double x) {
using FPB = fputil::FPBits<double>;
// Added some small value to umin and umax mantissa to avoid possible rounding
// errors.
@@ -99,7 +99,7 @@ constexpr double ASIN_COEFFS[10] = {0x1.5555555540fa1p-3, 0x1.333333512edc2p-4,
-0x1.df946fa875ddp-8, 0x1.02311ecf99c28p-5};
// Evaluate P(x^2) - 1, where P(x^2) ~ asin(x)/x
-static inline double asin_eval(double xsq) {
+LIBC_INLINE double asin_eval(double xsq) {
double x4 = xsq * xsq;
double r1 = fputil::polyeval(x4, ASIN_COEFFS[0], ASIN_COEFFS[2],
ASIN_COEFFS[4], ASIN_COEFFS[6], ASIN_COEFFS[8]);
diff --git a/libc/src/math/generic/math_utils.h b/libc/src/math/generic/math_utils.h
index 61c84dc630cfc..550117f7818e6 100644
--- a/libc/src/math/generic/math_utils.h
+++ b/libc/src/math/generic/math_utils.h
@@ -19,21 +19,21 @@
namespace __llvm_libc {
-static inline uint32_t as_uint32_bits(float x) {
+LIBC_INLINE uint32_t as_uint32_bits(float x) {
return cpp::bit_cast<uint32_t>(x);
}
-static inline uint64_t as_uint64_bits(double x) {
+LIBC_INLINE uint64_t as_uint64_bits(double x) {
return cpp::bit_cast<uint64_t>(x);
}
-static inline float as_float(uint32_t x) { return cpp::bit_cast<float>(x); }
+LIBC_INLINE float as_float(uint32_t x) { return cpp::bit_cast<float>(x); }
-static inline double as_double(uint64_t x) { return cpp::bit_cast<double>(x); }
+LIBC_INLINE double as_double(uint64_t x) { return cpp::bit_cast<double>(x); }
-static inline uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; }
+LIBC_INLINE uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; }
-static inline uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; }
+LIBC_INLINE uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; }
// Values to trigger underflow and overflow.
template <typename T> struct XFlowValues;
@@ -50,17 +50,17 @@ template <> struct XFlowValues<double> {
static const double MAY_UNDERFLOW_VALUE;
};
-template <typename T> static inline T with_errno(T x, int err) {
+template <typename T> LIBC_INLINE T with_errno(T x, int err) {
if (math_errhandling & MATH_ERRNO)
errno = err;
return x;
}
-template <typename T> static inline void force_eval(T x) {
+template <typename T> LIBC_INLINE void force_eval(T x) {
volatile T y UNUSED = x;
}
-template <typename T> static inline T opt_barrier(T x) {
+template <typename T> LIBC_INLINE T opt_barrier(T x) {
volatile T y = x;
return y;
}
@@ -96,7 +96,7 @@ T may_underflow(uint32_t sign) {
}
template <typename T, EnableIfFloatOrDouble<T> = 0>
-static inline constexpr float invalid(T x) {
+LIBC_INLINE constexpr float invalid(T x) {
T y = (x - x) / (x - x);
return isnan(x) ? y : with_errno(y, EDOM);
}
diff --git a/libc/src/math/generic/range_reduction.h b/libc/src/math/generic/range_reduction.h
index 095226608ee79..f620bcda0948f 100644
--- a/libc/src/math/generic/range_reduction.h
+++ b/libc/src/math/generic/range_reduction.h
@@ -12,6 +12,7 @@
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/multiply_add.h"
#include "src/__support/FPUtil/nearest_integer.h"
+#include "src/__support/common.h"
namespace __llvm_libc {
@@ -40,7 +41,7 @@ static constexpr int THIRTYTWO_OVER_PI_28_LSB_EXP[N_ENTRIES] = {
// Return k and y, where
// k = round(x * 16 / pi) and y = (x * 16 / pi) - k.
-static inline int64_t small_range_reduction(double x, double &y) {
+LIBC_INLINE int64_t small_range_reduction(double x, double &y) {
double prod = x * THIRTYTWO_OVER_PI_28[0];
double kd = fputil::nearest_integer(prod);
y = prod - kd;
@@ -55,7 +56,7 @@ static inline int64_t small_range_reduction(double x, double &y) {
// contributing to the lowest 6 binary digits (k & 63). If the least
// significant bit of x * the least significant bit of THIRTYTWO_OVER_PI_28[i]
// >= 64, we can completely ignore THIRTYTWO_OVER_PI_28[i].
-static inline int64_t large_range_reduction(double x, int x_exp, double &y) {
+LIBC_INLINE int64_t large_range_reduction(double x, int x_exp, double &y) {
int idx = 0;
y = 0;
int x_lsb_exp_m4 = x_exp - fputil::FloatProperties<float>::MANTISSA_WIDTH;
diff --git a/libc/src/math/generic/range_reduction_fma.h b/libc/src/math/generic/range_reduction_fma.h
index 102c1d7a59254..79c076d265c67 100644
--- a/libc/src/math/generic/range_reduction_fma.h
+++ b/libc/src/math/generic/range_reduction_fma.h
@@ -12,6 +12,7 @@
#include "src/__support/FPUtil/FMA.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/nearest_integer.h"
+#include "src/__support/common.h"
namespace __llvm_libc {
@@ -30,7 +31,7 @@ static constexpr double THIRTYTWO_OVER_PI[5] = {
// Return k and y, where
// k = round(x * 32 / pi) and y = (x * 32 / pi) - k.
-static inline int64_t small_range_reduction(double x, double &y) {
+LIBC_INLINE int64_t small_range_reduction(double x, double &y) {
double kd = fputil::nearest_integer(x * THIRTYTWO_OVER_PI[0]);
y = fputil::fma(x, THIRTYTWO_OVER_PI[0], -kd);
y = fputil::fma(x, THIRTYTWO_OVER_PI[1], y);
@@ -40,7 +41,7 @@ static inline int64_t small_range_reduction(double x, double &y) {
// Return k and y, where
// k = round(x * 32 / pi) and y = (x * 32 / pi) - k.
// This is used for sinf, cosf, sincosf.
-static inline int64_t large_range_reduction(double x, int x_exp, double &y) {
+LIBC_INLINE int64_t large_range_reduction(double x, int x_exp, double &y) {
// 2^45 <= |x| < 2^99
if (x_exp < 99) {
// - When x < 2^99, the full exact product of x * THIRTYTWO_OVER_PI[0]
diff --git a/libc/src/math/generic/sincosf_utils.h b/libc/src/math/generic/sincosf_utils.h
index 38ee2784de5a9..a193216480b70 100644
--- a/libc/src/math/generic/sincosf_utils.h
+++ b/libc/src/math/generic/sincosf_utils.h
@@ -58,8 +58,8 @@ const double SIN_K_PI_OVER_32[64] = {
-0x1.917a6bc29b42cp-4,
};
-static inline void sincosf_eval(double xd, uint32_t x_abs, double &sin_k,
- double &cos_k, double &sin_y, double &cosm1_y) {
+LIBC_INLINE void sincosf_eval(double xd, uint32_t x_abs, double &sin_k,
+ double &cos_k, double &sin_y, double &cosm1_y) {
int64_t k;
double y;
diff --git a/libc/src/pthread/CMakeLists.txt b/libc/src/pthread/CMakeLists.txt
index ca5f45efc809b..210de837189e8 100644
--- a/libc/src/pthread/CMakeLists.txt
+++ b/libc/src/pthread/CMakeLists.txt
@@ -103,6 +103,7 @@ add_header_library(
HDRS
pthread_mutexattr.h
DEPENDS
+ libc.src.__support.common
libc.include.pthread
)
diff --git a/libc/src/pthread/pthread_mutexattr.h b/libc/src/pthread/pthread_mutexattr.h
index 98f9ff9067e44..b65c672d34ce4 100644
--- a/libc/src/pthread/pthread_mutexattr.h
+++ b/libc/src/pthread/pthread_mutexattr.h
@@ -9,6 +9,8 @@
#ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_H
+#include "src/__support/common.h"
+
#include <pthread.h>
namespace __llvm_libc {
@@ -31,12 +33,12 @@ constexpr pthread_mutexattr_t DEFAULT_MUTEXATTR =
PTHREAD_MUTEX_STALLED << unsigned(PThreadMutexAttrPos::ROBUST_SHIFT) |
PTHREAD_PROCESS_PRIVATE << unsigned(PThreadMutexAttrPos::PSHARED_SHIFT);
-static inline int get_mutexattr_type(pthread_mutexattr_t attr) {
+LIBC_INLINE int get_mutexattr_type(pthread_mutexattr_t attr) {
return (attr & unsigned(PThreadMutexAttrPos::TYPE_MASK)) >>
unsigned(PThreadMutexAttrPos::TYPE_SHIFT);
}
-static inline int get_mutexattr_robust(pthread_mutexattr_t attr) {
+LIBC_INLINE int get_mutexattr_robust(pthread_mutexattr_t attr) {
return (attr & unsigned(PThreadMutexAttrPos::ROBUST_MASK)) >>
unsigned(PThreadMutexAttrPos::ROBUST_SHIFT);
}
diff --git a/libc/src/signal/linux/signal_utils.h b/libc/src/signal/linux/signal_utils.h
index 7c45e0862d524..ce8a07a8a8b5f 100644
--- a/libc/src/signal/linux/signal_utils.h
+++ b/libc/src/signal/linux/signal_utils.h
@@ -11,6 +11,7 @@
#include "include/sys/syscall.h" // For syscall numbers.
#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
#include <signal.h>
#include <stddef.h>
@@ -29,7 +30,7 @@ struct KernelSigaction {
using HandlerType = void(int);
using SiginfoHandlerType = void(int, siginfo_t *, void *);
- KernelSigaction &operator=(const struct sigaction &sa) {
+ LIBC_INLINE KernelSigaction &operator=(const struct sigaction &sa) {
sa_flags = sa.sa_flags;
sa_restorer = sa.sa_restorer;
sa_mask = sa.sa_mask;
@@ -41,7 +42,7 @@ struct KernelSigaction {
return *this;
}
- operator struct sigaction() const {
+ LIBC_INLINE operator struct sigaction() const {
struct sigaction sa;
sa.sa_flags = sa_flags;
sa.sa_mask = sa_mask;
@@ -63,14 +64,14 @@ struct KernelSigaction {
static constexpr size_t BITS_PER_SIGWORD = sizeof(unsigned long) * 8;
-constexpr sigset_t full_set() { return sigset_t{{-1UL}}; }
+LIBC_INLINE constexpr sigset_t full_set() { return sigset_t{{-1UL}}; }
-constexpr sigset_t empty_set() { return sigset_t{{0}}; }
+LIBC_INLINE constexpr sigset_t empty_set() { return sigset_t{{0}}; }
// Set the bit corresponding to |signal| in |set|. Return true on success
// and false on failure. The function will fail if |signal| is greater than
// NSIG or negative.
-constexpr inline bool add_signal(sigset_t &set, int signal) {
+LIBC_INLINE constexpr bool add_signal(sigset_t &set, int signal) {
if (signal > NSIG || signal <= 0)
return false;
size_t n = size_t(signal) - 1;
@@ -83,7 +84,7 @@ constexpr inline bool add_signal(sigset_t &set, int signal) {
// Reset the bit corresponding to |signal| in |set|. Return true on success
// and false on failure. The function will fail if |signal| is greater than
// NSIG or negative.
-constexpr inline bool delete_signal(sigset_t &set, int signal) {
+LIBC_INLINE constexpr bool delete_signal(sigset_t &set, int signal) {
if (signal > NSIG || signal <= 0)
return false;
size_t n = size_t(signal) - 1;
@@ -93,13 +94,13 @@ constexpr inline bool delete_signal(sigset_t &set, int signal) {
return true;
}
-static inline int block_all_signals(sigset_t &set) {
+LIBC_INLINE int block_all_signals(sigset_t &set) {
sigset_t full = full_set();
return __llvm_libc::syscall_impl(SYS_rt_sigprocmask, SIG_BLOCK, &full, &set,
sizeof(sigset_t));
}
-static inline int restore_signals(const sigset_t &set) {
+LIBC_INLINE int restore_signals(const sigset_t &set) {
return __llvm_libc::syscall_impl(SYS_rt_sigprocmask, SIG_SETMASK, &set,
nullptr, sizeof(sigset_t));
}
diff --git a/libc/src/string/CMakeLists.txt b/libc/src/string/CMakeLists.txt
index ec61735f41542..749cfab8d01f1 100644
--- a/libc/src/string/CMakeLists.txt
+++ b/libc/src/string/CMakeLists.txt
@@ -7,6 +7,7 @@ add_header_library(
DEPENDS
libc.include.stdlib
libc.src.__support.CPP.bitset
+ libc.src.__support.common
.memory_utils.memcpy_implementation
.memory_utils.bzero_implementation
)
diff --git a/libc/src/string/memory_utils/README.md b/libc/src/string/memory_utils/README.md
index 83a2906675f69..4b2069caba065 100644
--- a/libc/src/string/memory_utils/README.md
+++ b/libc/src/string/memory_utils/README.md
@@ -37,20 +37,20 @@ template <size_t Size>
struct Memset {
static constexpr size_t SIZE = Size;
- static inline void block(Ptr dst, uint8_t value) {
+ LIBC_INLINE static void block(Ptr dst, uint8_t value) {
// Implement me
}
- static inline void tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void tail(Ptr dst, uint8_t value, size_t count) {
block(dst + count - SIZE, value);
}
- static inline void head_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void head_tail(Ptr dst, uint8_t value, size_t count) {
block(dst, value);
tail(dst, value, count);
}
- static inline void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
size_t offset = 0;
do {
block(dst + offset, value);
diff --git a/libc/src/string/memory_utils/bzero_implementations.h b/libc/src/string/memory_utils/bzero_implementations.h
index 550c910def885..02780d7859a73 100644
--- a/libc/src/string/memory_utils/bzero_implementations.h
+++ b/libc/src/string/memory_utils/bzero_implementations.h
@@ -9,17 +9,18 @@
#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BZERO_IMPLEMENTATIONS_H
#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BZERO_IMPLEMENTATIONS_H
+#include "src/__support/common.h"
#include "src/string/memory_utils/memset_implementations.h"
#include <stddef.h> // size_t
namespace __llvm_libc {
-inline static void inline_bzero(Ptr dst, size_t count) {
+LIBC_INLINE static void inline_bzero(Ptr dst, size_t count) {
inline_memset(dst, 0, count);
}
-inline static void inline_bzero(void *dst, size_t count) {
+LIBC_INLINE static void inline_bzero(void *dst, size_t count) {
inline_bzero(reinterpret_cast<Ptr>(dst), count);
}
diff --git a/libc/src/string/memory_utils/memset_implementations.h b/libc/src/string/memory_utils/memset_implementations.h
index dbcc356bcdf07..c9d047c01044c 100644
--- a/libc/src/string/memory_utils/memset_implementations.h
+++ b/libc/src/string/memory_utils/memset_implementations.h
@@ -10,6 +10,7 @@
#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H
#include "src/__support/architectures.h"
+#include "src/__support/common.h"
#include "src/string/memory_utils/op_aarch64.h"
#include "src/string/memory_utils/op_builtin.h"
#include "src/string/memory_utils/op_generic.h"
@@ -20,7 +21,7 @@
namespace __llvm_libc {
-[[maybe_unused]] inline static void
+[[maybe_unused]] LIBC_INLINE static void
inline_memset_embedded_tiny(Ptr dst, uint8_t value, size_t count) {
LLVM_LIBC_LOOP_NOUNROLL
for (size_t offset = 0; offset < count; ++offset)
@@ -29,8 +30,8 @@ inline_memset_embedded_tiny(Ptr dst, uint8_t value, size_t count) {
#if defined(LLVM_LIBC_ARCH_X86)
template <size_t MaxSize>
-[[maybe_unused]] inline static void inline_memset_x86(Ptr dst, uint8_t value,
- size_t count) {
+[[maybe_unused]] LIBC_INLINE static void
+inline_memset_x86(Ptr dst, uint8_t value, size_t count) {
if (count == 0)
return;
if (count == 1)
@@ -58,7 +59,7 @@ template <size_t MaxSize>
#if defined(LLVM_LIBC_ARCH_AARCH64)
template <size_t MaxSize>
-[[maybe_unused]] inline static void
+[[maybe_unused]] LIBC_INLINE static void
inline_memset_aarch64(Ptr dst, uint8_t value, size_t count) {
if (count == 0)
return;
@@ -94,7 +95,7 @@ inline_memset_aarch64(Ptr dst, uint8_t value, size_t count) {
}
#endif // defined(LLVM_LIBC_ARCH_AARCH64)
-inline static void inline_memset(Ptr dst, uint8_t value, size_t count) {
+LIBC_INLINE static void inline_memset(Ptr dst, uint8_t value, size_t count) {
#if defined(LLVM_LIBC_ARCH_X86)
static constexpr size_t kMaxSize = x86::kAvx512F ? 64
: x86::kAvx ? 32
@@ -113,7 +114,7 @@ inline static void inline_memset(Ptr dst, uint8_t value, size_t count) {
#endif
}
-inline static void inline_memset(void *dst, uint8_t value, size_t count) {
+LIBC_INLINE static void inline_memset(void *dst, uint8_t value, size_t count) {
inline_memset(reinterpret_cast<Ptr>(dst), value, count);
}
diff --git a/libc/src/string/memory_utils/op_aarch64.h b/libc/src/string/memory_utils/op_aarch64.h
index cd64905f36f15..3d625c20c7624 100644
--- a/libc/src/string/memory_utils/op_aarch64.h
+++ b/libc/src/string/memory_utils/op_aarch64.h
@@ -55,7 +55,7 @@ template <size_t Size> struct BzeroCacheLine {
}
};
-inline static bool hasZva() {
+LIBC_INLINE static bool hasZva() {
uint64_t zva_val;
asm("mrs %[zva_val], dczid_el0" : [zva_val] "=r"(zva_val));
// DC ZVA is permitted if DZP, bit [4] is zero.
diff --git a/libc/src/string/memory_utils/op_builtin.h b/libc/src/string/memory_utils/op_builtin.h
index ce33de3e64678..cf90c02ef1dc1 100644
--- a/libc/src/string/memory_utils/op_builtin.h
+++ b/libc/src/string/memory_utils/op_builtin.h
@@ -23,7 +23,7 @@ namespace __llvm_libc::builtin {
// Memcpy
template <size_t Size> struct Memcpy {
static constexpr size_t SIZE = Size;
- static inline void block(Ptr __restrict dst, CPtr __restrict src) {
+ LIBC_INLINE static void block(Ptr __restrict dst, CPtr __restrict src) {
#ifdef LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
return __builtin_memcpy_inline(dst, src, SIZE);
#else
@@ -33,19 +33,19 @@ template <size_t Size> struct Memcpy {
#endif
}
- static inline void tail(Ptr __restrict dst, CPtr __restrict src,
- size_t count) {
+ LIBC_INLINE static void tail(Ptr __restrict dst, CPtr __restrict src,
+ size_t count) {
block(dst + count - SIZE, src + count - SIZE);
}
- static inline void head_tail(Ptr __restrict dst, CPtr __restrict src,
- size_t count) {
+ LIBC_INLINE static void head_tail(Ptr __restrict dst, CPtr __restrict src,
+ size_t count) {
block(dst, src);
tail(dst, src, count);
}
- static inline void loop_and_tail(Ptr __restrict dst, CPtr __restrict src,
- size_t count) {
+ LIBC_INLINE static void loop_and_tail(Ptr __restrict dst, CPtr __restrict src,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -61,7 +61,7 @@ template <size_t Size> struct Memcpy {
template <size_t Size> struct Memset {
using ME = Memset;
static constexpr size_t SIZE = Size;
- static inline void block(Ptr dst, uint8_t value) {
+ LIBC_INLINE static void block(Ptr dst, uint8_t value) {
#ifdef LLVM_LIBC_HAS_BUILTIN_MEMSET_INLINE
__builtin_memset_inline(dst, value, Size);
#else
@@ -71,16 +71,16 @@ template <size_t Size> struct Memset {
#endif
}
- static inline void tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void tail(Ptr dst, uint8_t value, size_t count) {
block(dst + count - SIZE, value);
}
- static inline void head_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void head_tail(Ptr dst, uint8_t value, size_t count) {
block(dst, value);
tail(dst, value, count);
}
- static inline void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -96,22 +96,22 @@ template <size_t Size> struct Memset {
template <size_t Size> struct Bcmp {
using ME = Bcmp;
static constexpr size_t SIZE = Size;
- static inline BcmpReturnType block(CPtr, CPtr) {
+ LIBC_INLINE static BcmpReturnType block(CPtr, CPtr) {
deferred_static_assert("Missing __builtin_memcmp_inline");
return BcmpReturnType::ZERO();
}
- static inline BcmpReturnType tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static BcmpReturnType tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return BcmpReturnType::ZERO();
}
- static inline BcmpReturnType head_tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static BcmpReturnType head_tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return BcmpReturnType::ZERO();
}
- static inline BcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static BcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return BcmpReturnType::ZERO();
}
@@ -122,22 +122,22 @@ template <size_t Size> struct Bcmp {
template <size_t Size> struct Memcmp {
using ME = Memcmp;
static constexpr size_t SIZE = Size;
- static inline MemcmpReturnType block(CPtr, CPtr) {
+ LIBC_INLINE static MemcmpReturnType block(CPtr, CPtr) {
deferred_static_assert("Missing __builtin_memcmp_inline");
return MemcmpReturnType::ZERO();
}
- static inline MemcmpReturnType tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static MemcmpReturnType tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return MemcmpReturnType::ZERO();
}
- static inline MemcmpReturnType head_tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static MemcmpReturnType head_tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return MemcmpReturnType::ZERO();
}
- static inline MemcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
+ LIBC_INLINE static MemcmpReturnType loop_and_tail(CPtr, CPtr, size_t) {
deferred_static_assert("Not implemented");
return MemcmpReturnType::ZERO();
}
diff --git a/libc/src/string/memory_utils/op_generic.h b/libc/src/string/memory_utils/op_generic.h
index 1603dbf4ebfd2..3d505fbd9d2c1 100644
--- a/libc/src/string/memory_utils/op_generic.h
+++ b/libc/src/string/memory_utils/op_generic.h
@@ -46,7 +46,9 @@ namespace __llvm_libc::generic {
// using UInt8T = MyMap::find_type<1>;
template <size_t I, typename T> struct CTPair {
using type = T;
- static CTPair get_pair(cpp::integral_constant<size_t, I>) { return {}; }
+ LIBC_INLINE static CTPair get_pair(cpp::integral_constant<size_t, I>) {
+ return {};
+ }
};
template <typename... Pairs> struct CTMap : public Pairs... {
using Pairs::get_pair...;
@@ -63,11 +65,13 @@ template <typename T> struct ScalarType {
using Type = T;
static_assert(cpp::is_integral_v<Type> && !cpp::is_signed_v<Type>);
- static inline Type load(CPtr src) { return ::__llvm_libc::load<Type>(src); }
- static inline void store(Ptr dst, Type value) {
+ LIBC_INLINE static Type load(CPtr src) {
+ return ::__llvm_libc::load<Type>(src);
+ }
+ LIBC_INLINE static void store(Ptr dst, Type value) {
::__llvm_libc::store<Type>(dst, value);
}
- static inline Type splat(uint8_t value) {
+ LIBC_INLINE static Type splat(uint8_t value) {
return Type(~0) / Type(0xFF) * Type(value);
}
};
@@ -100,11 +104,13 @@ template <> struct VectorValueType<64> {
// Implements load, store and splat for vector types.
template <size_t Size> struct VectorType {
using Type = typename VectorValueType<Size>::type;
- static inline Type load(CPtr src) { return ::__llvm_libc::load<Type>(src); }
- static inline void store(Ptr dst, Type value) {
+ LIBC_INLINE static Type load(CPtr src) {
+ return ::__llvm_libc::load<Type>(src);
+ }
+ LIBC_INLINE static void store(Ptr dst, Type value) {
::__llvm_libc::store<Type>(dst, value);
}
- static inline Type splat(uint8_t value) {
+ LIBC_INLINE static Type splat(uint8_t value) {
Type Out;
// This for loop is optimized out for vector types.
for (size_t i = 0; i < Size; ++i)
@@ -140,17 +146,17 @@ using NativeTypeMap =
template <typename SubType, size_t ArraySize> struct ArrayType {
using Type = cpp::array<typename SubType::Type, ArraySize>;
static constexpr size_t SizeOfElement = sizeof(typename SubType::Type);
- static inline Type load(CPtr src) {
+ LIBC_INLINE static Type load(CPtr src) {
Type Value;
for (size_t I = 0; I < ArraySize; ++I)
Value[I] = SubType::load(src + (I * SizeOfElement));
return Value;
}
- static inline void store(Ptr dst, Type Value) {
+ LIBC_INLINE static void store(Ptr dst, Type Value) {
for (size_t I = 0; I < ArraySize; ++I)
SubType::store(dst + (I * SizeOfElement), Value[I]);
}
- static inline Type splat(uint8_t value) {
+ LIBC_INLINE static Type splat(uint8_t value) {
Type Out;
for (size_t I = 0; I < ArraySize; ++I)
Out[I] = SubType::splat(value);
@@ -190,7 +196,7 @@ template <size_t Size, size_t MaxSize> struct Memset {
static_assert(is_power2(MaxSize));
static constexpr size_t SIZE = Size;
- static inline void block(Ptr dst, uint8_t value) {
+ LIBC_INLINE static void block(Ptr dst, uint8_t value) {
if constexpr (Size == 3) {
Memset<1, MaxSize>::block(dst + 2, value);
Memset<2, MaxSize>::block(dst, value);
@@ -204,16 +210,16 @@ template <size_t Size, size_t MaxSize> struct Memset {
}
}
- static inline void tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void tail(Ptr dst, uint8_t value, size_t count) {
block(dst + count - SIZE, value);
}
- static inline void head_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void head_tail(Ptr dst, uint8_t value, size_t count) {
block(dst, value);
tail(dst, value, count);
}
- static inline void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
+ LIBC_INLINE static void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
static_assert(SIZE > 1);
size_t offset = 0;
do {
@@ -233,16 +239,16 @@ template <size_t Size> struct Bcmp {
? sizeof(uint64_t)
: sizeof(uint32_t);
- template <typename T> static inline uint32_t load_xor(CPtr p1, CPtr p2) {
+ template <typename T> LIBC_INLINE static uint32_t load_xor(CPtr p1, CPtr p2) {
return load<T>(p1) ^ load<T>(p2);
}
template <typename T>
- static inline uint32_t load_not_equal(CPtr p1, CPtr p2) {
+ LIBC_INLINE static uint32_t load_not_equal(CPtr p1, CPtr p2) {
return load<T>(p1) != load<T>(p2);
}
- static inline BcmpReturnType block(CPtr p1, CPtr p2) {
+ LIBC_INLINE static BcmpReturnType block(CPtr p1, CPtr p2) {
if constexpr (Size == 1) {
return load_xor<uint8_t>(p1, p2);
} else if constexpr (Size == 2) {
@@ -261,15 +267,16 @@ template <size_t Size> struct Bcmp {
return BcmpReturnType::ZERO();
}
- static inline BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
return block(p1 + count - SIZE, p2 + count - SIZE);
}
- static inline BcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
return block(p1, p2) | tail(p1, p2, count);
}
- static inline BcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -290,23 +297,23 @@ template <size_t Size> struct Memcmp {
? sizeof(uint64_t)
: sizeof(uint32_t);
- template <typename T> static inline T load_be(CPtr ptr) {
+ template <typename T> LIBC_INLINE static T load_be(CPtr ptr) {
return Endian::to_big_endian(load<T>(ptr));
}
template <typename T>
- static inline MemcmpReturnType load_be_
diff (CPtr p1, CPtr p2) {
+ LIBC_INLINE static MemcmpReturnType load_be_
diff (CPtr p1, CPtr p2) {
return load_be<T>(p1) - load_be<T>(p2);
}
template <typename T>
- static inline MemcmpReturnType load_be_cmp(CPtr p1, CPtr p2) {
+ LIBC_INLINE static MemcmpReturnType load_be_cmp(CPtr p1, CPtr p2) {
const auto la = load_be<T>(p1);
const auto lb = load_be<T>(p2);
return la > lb ? 1 : la < lb ? -1 : 0;
}
- static inline MemcmpReturnType block(CPtr p1, CPtr p2) {
+ LIBC_INLINE static MemcmpReturnType block(CPtr p1, CPtr p2) {
if constexpr (Size == 1) {
return load_be_
diff <uint8_t>(p1, p2);
} else if constexpr (Size == 2) {
@@ -329,17 +336,19 @@ template <size_t Size> struct Memcmp {
}
}
- static inline MemcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
return block(p1 + count - SIZE, p2 + count - SIZE);
}
- static inline MemcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType head_tail(CPtr p1, CPtr p2,
+ size_t count) {
if (auto value = block(p1, p2))
return value;
return tail(p1, p2, count);
}
- static inline MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -360,7 +369,7 @@ template <size_t Size, size_t MaxSize> struct Memmove {
using T = getTypeFor<Size, MaxSize>;
static constexpr size_t SIZE = Size;
- static inline void block(Ptr dst, CPtr src) {
+ LIBC_INLINE static void block(Ptr dst, CPtr src) {
if constexpr (is_void_v<T>) {
deferred_static_assert("Unimplemented Size");
} else {
@@ -368,7 +377,7 @@ template <size_t Size, size_t MaxSize> struct Memmove {
}
}
- static inline void head_tail(Ptr dst, CPtr src, size_t count) {
+ LIBC_INLINE static void head_tail(Ptr dst, CPtr src, size_t count) {
const size_t offset = count - Size;
if constexpr (is_void_v<T>) {
deferred_static_assert("Unimplemented Size");
@@ -402,7 +411,7 @@ template <size_t Size, size_t MaxSize> struct Memmove {
// [_SSSSSSSS________________________]
// [___SSSSSSSA______________________]
template <Arg AlignOn>
- static inline void align_forward(Ptr &dst, CPtr &src, size_t &count) {
+ LIBC_INLINE static void align_forward(Ptr &dst, CPtr &src, size_t &count) {
Ptr prev_dst = dst;
CPtr prev_src = src;
size_t prev_count = count;
@@ -430,7 +439,7 @@ template <size_t Size, size_t MaxSize> struct Memmove {
// [__________________ASSSSSSS_______]
// [______________________SSSSSSSS___]
template <Arg AlignOn>
- static inline void align_backward(Ptr &dst, CPtr &src, size_t &count) {
+ LIBC_INLINE static void align_backward(Ptr &dst, CPtr &src, size_t &count) {
Ptr headtail_dst = dst + count;
CPtr headtail_src = src + count;
size_t headtail_size = 0;
@@ -455,7 +464,8 @@ template <size_t Size, size_t MaxSize> struct Memmove {
// [___________________LLLLLLLL_________]
// [_________________SSSSSSSS___________]
// [_______________________SSSSSSSS_____]
- static inline void loop_and_tail_forward(Ptr dst, CPtr src, size_t count) {
+ LIBC_INLINE static void loop_and_tail_forward(Ptr dst, CPtr src,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
const size_t tail_offset = count - Size;
const auto tail_value = T::load(src + tail_offset);
@@ -482,7 +492,8 @@ template <size_t Size, size_t MaxSize> struct Memmove {
// [_________LLLLLLLL___________________]
// [___________SSSSSSSS_________________]
// [_____SSSSSSSS_______________________]
- static inline void loop_and_tail_backward(Ptr dst, CPtr src, size_t count) {
+ LIBC_INLINE static void loop_and_tail_backward(Ptr dst, CPtr src,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
const auto head_value = T::load(src);
ptr
diff _t offset = count - Size;
diff --git a/libc/src/string/memory_utils/op_x86.h b/libc/src/string/memory_utils/op_x86.h
index b2355d9555eb5..dd96e9c9aec1a 100644
--- a/libc/src/string/memory_utils/op_x86.h
+++ b/libc/src/string/memory_utils/op_x86.h
@@ -64,7 +64,7 @@ struct Memcpy {
// - BlockBcmp is the function that implements the bcmp logic.
template <size_t Size, size_t BlockSize, auto BlockBcmp> struct BcmpImpl {
static constexpr size_t SIZE = Size;
- static inline BcmpReturnType block(CPtr p1, CPtr p2) {
+ LIBC_INLINE static BcmpReturnType block(CPtr p1, CPtr p2) {
if constexpr (Size == BlockSize) {
return BlockBcmp(p1, p2);
} else if constexpr (Size % BlockSize == 0) {
@@ -77,15 +77,16 @@ template <size_t Size, size_t BlockSize, auto BlockBcmp> struct BcmpImpl {
return BcmpReturnType::ZERO();
}
- static inline BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
return block(p1 + count - Size, p2 + count - Size);
}
- static inline BcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
return block(p1, p2) | tail(p1, p2, count);
}
- static inline BcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static BcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -98,7 +99,7 @@ template <size_t Size, size_t BlockSize, auto BlockBcmp> struct BcmpImpl {
};
namespace sse2 {
-static inline BcmpReturnType bcmp16(CPtr p1, CPtr p2) {
+LIBC_INLINE BcmpReturnType bcmp16(CPtr p1, CPtr p2) {
#if defined(__SSE2__)
using T = char __attribute__((__vector_size__(16)));
// A mask indicating which bytes
diff er after loading 16 bytes from p1 and p2.
@@ -115,7 +116,7 @@ template <size_t Size> using Bcmp = BcmpImpl<Size, 16, bcmp16>;
} // namespace sse2
namespace avx2 {
-static inline BcmpReturnType bcmp32(CPtr p1, CPtr p2) {
+LIBC_INLINE BcmpReturnType bcmp32(CPtr p1, CPtr p2) {
#if defined(__AVX2__)
using T = char __attribute__((__vector_size__(32)));
// A mask indicating which bytes
diff er after loading 32 bytes from p1 and p2.
@@ -134,7 +135,7 @@ template <size_t Size> using Bcmp = BcmpImpl<Size, 32, bcmp32>;
} // namespace avx2
namespace avx512bw {
-static inline BcmpReturnType bcmp64(CPtr p1, CPtr p2) {
+LIBC_INLINE BcmpReturnType bcmp64(CPtr p1, CPtr p2) {
#if defined(__AVX512BW__)
using T = char __attribute__((__vector_size__(64)));
// A mask indicating which bytes
diff er after loading 64 bytes from p1 and p2.
@@ -154,8 +155,8 @@ template <size_t Size> using Bcmp = BcmpImpl<Size, 64, bcmp64>;
// Assuming that the mask is non zero, the index of the first mismatching byte
// is the number of trailing zeros in the mask. Trailing zeros and not leading
// zeros because the x86 architecture is little endian.
-static inline MemcmpReturnType char_
diff _no_zero(CPtr p1, CPtr p2,
- uint64_t mask) {
+LIBC_INLINE MemcmpReturnType char_
diff _no_zero(CPtr p1, CPtr p2,
+ uint64_t mask) {
const size_t
diff _index = __builtin_ctzll(mask);
const int16_t ca = cpp::to_integer<uint8_t>(p1[
diff _index]);
const int16_t cb = cpp::to_integer<uint8_t>(p2[
diff _index]);
@@ -174,7 +175,7 @@ static inline MemcmpReturnType char_
diff _no_zero(CPtr p1, CPtr p2,
template <size_t Size, size_t BlockSize, auto BlockMemcmp, auto BlockBcmp>
struct MemcmpImpl {
static constexpr size_t SIZE = Size;
- static inline MemcmpReturnType block(CPtr p1, CPtr p2) {
+ LIBC_INLINE static MemcmpReturnType block(CPtr p1, CPtr p2) {
if constexpr (Size == BlockSize) {
return BlockMemcmp(p1, p2);
} else if constexpr (Size % BlockSize == 0) {
@@ -187,17 +188,19 @@ struct MemcmpImpl {
return MemcmpReturnType::ZERO();
}
- static inline MemcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
return block(p1 + count - Size, p2 + count - Size);
}
- static inline MemcmpReturnType head_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType head_tail(CPtr p1, CPtr p2,
+ size_t count) {
if (auto value = block(p1, p2))
return value;
return tail(p1, p2, count);
}
- static inline MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2, size_t count) {
+ LIBC_INLINE static MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
+ size_t count) {
static_assert(Size > 1, "a loop of size 1 does not need tail");
size_t offset = 0;
do {
@@ -210,7 +213,7 @@ struct MemcmpImpl {
};
namespace sse2 {
-static inline MemcmpReturnType memcmp16(CPtr p1, CPtr p2) {
+LIBC_INLINE MemcmpReturnType memcmp16(CPtr p1, CPtr p2) {
#if defined(__SSE2__)
using T = char __attribute__((__vector_size__(16)));
// A mask indicating which bytes
diff er after loading 16 bytes from p1 and p2.
@@ -228,7 +231,7 @@ template <size_t Size> using Memcmp = MemcmpImpl<Size, 16, memcmp16, bcmp16>;
} // namespace sse2
namespace avx2 {
-static inline MemcmpReturnType memcmp32(CPtr p1, CPtr p2) {
+LIBC_INLINE MemcmpReturnType memcmp32(CPtr p1, CPtr p2) {
#if defined(__AVX2__)
using T = char __attribute__((__vector_size__(32)));
// A mask indicating which bytes
diff er after loading 32 bytes from p1 and p2.
@@ -246,7 +249,7 @@ template <size_t Size> using Memcmp = MemcmpImpl<Size, 32, memcmp32, bcmp32>;
} // namespace avx2
namespace avx512bw {
-static inline MemcmpReturnType memcmp64(CPtr p1, CPtr p2) {
+LIBC_INLINE MemcmpReturnType memcmp64(CPtr p1, CPtr p2) {
#if defined(__AVX512BW__)
using T = char __attribute__((__vector_size__(64)));
// A mask indicating which bytes
diff er after loading 64 bytes from p1 and p2.
diff --git a/libc/src/string/memory_utils/utils.h b/libc/src/string/memory_utils/utils.h
index 6abc85d390dd6..8e5ddd6723cea 100644
--- a/libc/src/string/memory_utils/utils.h
+++ b/libc/src/string/memory_utils/utils.h
@@ -12,6 +12,7 @@
#include "src/__support/CPP/bit.h"
#include "src/__support/CPP/cstddef.h"
#include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
#include "src/__support/compiler_features.h"
#include <stddef.h> // size_t
@@ -91,8 +92,8 @@ template <size_t alignment, typename T> static T *assume_aligned(T *ptr) {
// Performs a constant count copy.
template <size_t Size>
-static inline void memcpy_inline(void *__restrict dst,
- const void *__restrict src) {
+LIBC_INLINE void memcpy_inline(void *__restrict dst,
+ const void *__restrict src) {
#ifdef LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
__builtin_memcpy_inline(dst, src, Size);
#else
@@ -130,7 +131,7 @@ template <typename T> struct StrictIntegralType {
}
// Helper to get the zero value.
- static inline constexpr StrictIntegralType ZERO() { return {T(0)}; }
+ LIBC_INLINE static constexpr StrictIntegralType ZERO() { return {T(0)}; }
private:
T value;
@@ -141,22 +142,22 @@ using BcmpReturnType = StrictIntegralType<uint32_t>;
// Loads bytes from memory (possibly unaligned) and materializes them as
// type.
-template <typename T> static inline T load(CPtr ptr) {
+template <typename T> LIBC_INLINE T load(CPtr ptr) {
T Out;
memcpy_inline<sizeof(T)>(&Out, ptr);
return Out;
}
// Stores a value of type T in memory (possibly unaligned).
-template <typename T> static inline void store(Ptr ptr, T value) {
+template <typename T> LIBC_INLINE void store(Ptr ptr, T value) {
memcpy_inline<sizeof(T)>(ptr, &value);
}
// Advances the pointers p1 and p2 by offset bytes and decrease count by the
// same amount.
template <typename T1, typename T2>
-static inline void adjust(ptr
diff _t offset, T1 *__restrict &p1,
- T2 *__restrict &p2, size_t &count) {
+LIBC_INLINE void adjust(ptr
diff _t offset, T1 *__restrict &p1,
+ T2 *__restrict &p2, size_t &count) {
p1 += offset;
p2 += offset;
count -= offset;
diff --git a/libc/src/string/string_utils.h b/libc/src/string/string_utils.h
index 24be2ab889b54..c6f0acb6949fe 100644
--- a/libc/src/string/string_utils.h
+++ b/libc/src/string/string_utils.h
@@ -58,7 +58,7 @@ template <typename Word> constexpr bool has_zeroes(Word block) {
}
template <typename Word>
-static inline size_t string_length_wide_read(const char *src) {
+LIBC_INLINE size_t string_length_wide_read(const char *src) {
const char *char_ptr = src;
// Step 1: read 1 byte at a time to align to block size
for (; reinterpret_cast<uintptr_t>(char_ptr) % sizeof(Word) != 0;
@@ -78,7 +78,7 @@ static inline size_t string_length_wide_read(const char *src) {
return char_ptr - src;
}
-static inline size_t string_length_byte_read(const char *src) {
+LIBC_INLINE size_t string_length_byte_read(const char *src) {
size_t length;
for (length = 0; *src; ++src, ++length)
;
@@ -87,7 +87,7 @@ static inline size_t string_length_byte_read(const char *src) {
// Returns the length of a string, denoted by the first occurrence
// of a null terminator.
-static inline size_t string_length(const char *src) {
+LIBC_INLINE size_t string_length(const char *src) {
#ifdef LIBC_UNSAFE_STRING_WIDE_READ
// Unsigned int is the default size for most processors, and on x86-64 it
// performs better than larger sizes when the src pointer can't be assumed to
@@ -100,8 +100,8 @@ static inline size_t string_length(const char *src) {
}
template <typename Word>
-static inline void *find_first_character_wide_read(const unsigned char *src,
- unsigned char ch, size_t n) {
+LIBC_INLINE void *find_first_character_wide_read(const unsigned char *src,
+ unsigned char ch, size_t n) {
const unsigned char *char_ptr = src;
size_t cur = 0;
@@ -132,8 +132,8 @@ static inline void *find_first_character_wide_read(const unsigned char *src,
return const_cast<unsigned char *>(char_ptr);
}
-static inline void *find_first_character_byte_read(const unsigned char *src,
- unsigned char ch, size_t n) {
+LIBC_INLINE void *find_first_character_byte_read(const unsigned char *src,
+ unsigned char ch, size_t n) {
for (; n && *src != ch; --n, ++src)
;
return n ? const_cast<unsigned char *>(src) : nullptr;
@@ -141,8 +141,8 @@ static inline void *find_first_character_byte_read(const unsigned char *src,
// Returns the first occurrence of 'ch' within the first 'n' characters of
// 'src'. If 'ch' is not found, returns nullptr.
-static inline void *find_first_character(const unsigned char *src,
- unsigned char ch, size_t max_strlen) {
+LIBC_INLINE void *find_first_character(const unsigned char *src,
+ unsigned char ch, size_t max_strlen) {
#ifdef LIBC_UNSAFE_STRING_WIDE_READ
// If the maximum size of the string is small, the overhead of aligning to a
// word boundary and generating a bitmask of the appropriate size may be
@@ -161,7 +161,7 @@ static inline void *find_first_character(const unsigned char *src,
// Returns the maximum length span that contains only characters not found in
// 'segment'. If no characters are found, returns the length of 'src'.
-static inline size_t complementary_span(const char *src, const char *segment) {
+LIBC_INLINE size_t complementary_span(const char *src, const char *segment) {
const char *initial = src;
cpp::bitset<256> bitset;
@@ -181,9 +181,9 @@ static inline size_t complementary_span(const char *src, const char *segment) {
// is found is then stored within 'context' for subsequent calls. Subsequent
// calls will use 'context' when a nullptr is passed in for 'src'. Once the null
// terminating character is reached, returns a nullptr.
-static inline char *string_token(char *__restrict src,
- const char *__restrict delimiter_string,
- char **__restrict saveptr) {
+LIBC_INLINE char *string_token(char *__restrict src,
+ const char *__restrict delimiter_string,
+ char **__restrict saveptr) {
// Return nullptr immediately if both src AND saveptr are nullptr
if (unlikely(src == nullptr && ((src = *saveptr) == nullptr)))
return nullptr;
@@ -210,8 +210,8 @@ static inline char *string_token(char *__restrict src,
return token;
}
-static inline size_t strlcpy(char *__restrict dst, const char *__restrict src,
- size_t size) {
+LIBC_INLINE size_t strlcpy(char *__restrict dst, const char *__restrict src,
+ size_t size) {
size_t len = internal::string_length(src);
if (!size)
return len;
diff --git a/libc/src/time/time_utils.h b/libc/src/time/time_utils.h
index 62a347f61e8ef..a4d51d8042db5 100644
--- a/libc/src/time/time_utils.h
+++ b/libc/src/time/time_utils.h
@@ -13,6 +13,7 @@
#include "include/errno.h"
+#include "src/__support/common.h"
#include "src/errno/llvmlibc_errno.h"
#include "src/time/mktime.h"
@@ -68,15 +69,15 @@ struct TimeConstants {
extern int64_t update_from_seconds(int64_t total_seconds, struct tm *tm);
// POSIX.1-2017 requires this.
-static inline time_t out_of_range() {
+LIBC_INLINE time_t out_of_range() {
llvmlibc_errno = EOVERFLOW;
return static_cast<time_t>(-1);
}
-static inline void invalid_value() { llvmlibc_errno = EINVAL; }
+LIBC_INLINE void invalid_value() { llvmlibc_errno = EINVAL; }
-static inline char *asctime(const struct tm *timeptr, char *buffer,
- size_t bufferLength) {
+LIBC_INLINE char *asctime(const struct tm *timeptr, char *buffer,
+ size_t bufferLength) {
if (timeptr == nullptr || buffer == nullptr) {
invalid_value();
return nullptr;
@@ -113,8 +114,7 @@ static inline char *asctime(const struct tm *timeptr, char *buffer,
return buffer;
}
-static inline struct tm *gmtime_internal(const time_t *timer,
- struct tm *result) {
+LIBC_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 (update_from_seconds(seconds, result) < 0) {
diff --git a/utils/bazel/llvm-project-overlay/libc/BUILD.bazel b/utils/bazel/llvm-project-overlay/libc/BUILD.bazel
index 3d2a8d59eb542..be4dafdc3b8b5 100644
--- a/utils/bazel/llvm-project-overlay/libc/BUILD.bazel
+++ b/utils/bazel/llvm-project-overlay/libc/BUILD.bazel
@@ -699,6 +699,7 @@ libc_support_library(
"src/math/generic/range_reduction_fma.h",
],
deps = [
+ ":__support_common",
":__support_fputil_fma",
":__support_fputil_fp_bits",
":__support_fputil_multiply_add",
More information about the libc-commits
mailing list