[libc][NFC] Another round of replacement of static inline with LIBC_INLINE.

libc/src/__support/FPUtil/FPBits.h

template <typename T> struct FPBits {
   // integer value as a floating point value is used in tests. So, a convenient
   // type is provided for such reinterpretations.
   using FloatProp = FloatProperties<T>;
   // TODO: Change UintType name to BitsType for consistency.
   using UIntType = typename FloatProp::BitsType;
 
   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 different sizes.");
 
   static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
   static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
 
   static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
template <typename T> struct FPBits {
   constexpr explicit FPBits(XType x) : bits(cpp::bit_cast<UIntType>(x)) {}
 
   template <typename XType,
             cpp::enable_if_t<cpp::is_same_v<XType, UIntType>, int> = 0>
   constexpr explicit FPBits(XType x) : bits(x) {}
 
   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);
   }
 
   // The function convert integer number and unbiased exponent to proper float
   // T type:
   //   Result = number * 2^(ep+1 - exponent_bias)
   // Be careful!
   //   1) "ep" is raw exponent value.
   //   2) The function add to +1 to ep for seamless normalized to denormalized
   //      transition.
   //   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;
     number <<= lz;
     ep -= lz;
 
     if (likely(ep >= 0)) {
       // Implicit number bit will be removed by mask
       result.set_mantissa(number);
       result.set_unbiased_exponent(ep + 1);
     } else {
       result.set_mantissa(number >> -ep);
     }
     return result;
   }
 
-  inline static FPBits<T> create_value(bool sign, UIntType unbiased_exp,
+  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);
     result.set_mantissa(mantissa);
     return result;
   }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/LongDoubleBits.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 //===-- Bit representation of x86 long double numbers -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 
 #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"
 #endif
 
 #include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
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 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;
     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::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));
   }
 
   FPBits() : bits(0) {}
 
   template <typename XType,
             cpp::enable_if_t<cpp::is_same_v<long double, XType>, int> = 0>
   explicit FPBits(XType x) : bits(cpp::bit_cast<UIntType>(x)) {
     // bits starts uninitialized, and setting it to a long double only
     // overwrites the first 80 bits. This clears those upper bits.
     bits = bits & ((UIntType(1) << 80) - 1);
   }
 
   template <typename XType,
             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 -
                          Padding<sizeof(uintptr_t)>::VALUE)) -
         1;
     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) {
       return get_implicit_bit() == 0;
     }
     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);
     bits.set_sign(1);
     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);
     bits.set_mantissa(v);
     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);
     result.set_unbiased_exponent(unbiased_exp);
     result.set_mantissa(mantissa);
     return result;
   }
 };

libc/src/math/generic/CMakeLists.txt

add_header_library(
   HDRS
     range_reduction.h
     range_reduction_fma.h
   DEPENDS
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.fma
     libc.src.__support.FPUtil.multiply_add
     libc.src.__support.FPUtil.nearest_integer
+    libc.src.__support.common
 )
 
 add_header_library(
   sincosf_utils
   HDRS
     sincosf_utils.h
   DEPENDS
     .range_reduction
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.polyeval
+    libc.src.__support.common
 )
 
 add_entrypoint_object(
   cosf
   SRCS
     cosf.cpp
   HDRS
     ../cosf.h
add_object_library(
   DEPENDS
     .common_constants
     libc.src.__support.FPUtil.basic_operations
     libc.src.__support.FPUtil.fenv_impl
     libc.src.__support.FPUtil.fp_bits
     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
   COMPILE_OPTIONS
     -O3
 )
 
 add_entrypoint_object(
SRCS
     inv_trigf_utils.cpp
   DEPENDS
     .math_utils
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.fenv_impl
     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
 )
 
 add_entrypoint_object(
   asinf
   SRCS

libc/src/math/generic/explogxf.h

struct ExpBase {
   // Approximating e^dx with degree-5 minimax polynomial generated by Sollya:
   // > Q = fpminimax(expm1(x)/x, 4, [|1, D...|], [-log(2)/64, log(2)/64]);
   // Then:
   //   e^dx ~ P(dx) = 1 + dx + COEFFS[0] * dx^2 + ... + COEFFS[3] * dx^5.
   static constexpr double COEFFS[4] = {
       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;
     // c1 = COEFFS[0] + COEFFS[1] * dx
     double c1 = multiply_add(dx, ExpBase::COEFFS[1], ExpBase::COEFFS[0]);
     // c2 = COEFFS[2] + COEFFS[3] * dx
     double c2 = multiply_add(dx, ExpBase::COEFFS[3], ExpBase::COEFFS[2]);
     // r = c4 + c5 * dx^4

 //   - MID_BITS    : number of bits after decimal points used for mid
 //   - MID_MASK    : 2^MID_BITS - 1, mask to extract mid bits
 //   - LOG2_B      : log2(b) * 2^MID_BITS for scaling
 //   - M_LOGB_2_HI : high part of -log_b(2) * 2^(-MID_BITS)
 //   - M_LOGB_2_LO : low part of -log_b(2) * 2^(-MID_BITS)
 //   - 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);
   // k = round((hi + mid) * log2(b) * 2^MID_BITS)
   int k = static_cast<int>(kd);
   // hi = floor(kd * 2^(-MID_BITS))
   // exp_hi = shift hi to the exponent field of double precision.
   int64_t exp_hi = static_cast<int64_t>((k >> Base::MID_BITS))

 //                    lo * P_odd * (2^(hi + mid) + 2^(-(hi + mid))))
 // And similarly:
 //   cosh(x) = (e^x + e^(-x)) / 2
 //           ~ 0.5 * (P_even * (2^(hi + mid) + 2^(-(hi + mid))) +
 //                    lo * P_odd * (2^(hi + mid) - 2^(-(hi + mid))))
 // 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)
   double kd = fputil::nearest_integer(ExpBase::LOG2_B * xd);
 
   // k_p = round(x * log2(e) * 2^5)
   int k_p = static_cast<int>(kd);
   // k_m = round(-x * log2(e) * 2^5)
template <bool is_sinh> LIBC_INLINE double exp_pm_eval(float x) {
   if constexpr (is_sinh)
     r = fputil::multiply_add(dx * mh_sum, p_odd, p_even * mh_diff);
   else
     r = fputil::multiply_add(dx * mh_diff, p_odd, p_even * mh_sum);
   return 0.5 * r;
 }
 
 // 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);
 
   double result = 0;
   result += bs.get_exponent();
 
   int p1 =
       (bs.get_mantissa() >> (FPB::FloatProp::MANTISSA_WIDTH - LOG_P1_BITS)) &
LIBC_INLINE static double log2_eval(double x) {
 
   // c0 = dx * (1.0 / ln(2)) + LOG_P1_LOG2[p1]
   double c0 = fputil::multiply_add(dx, 0x1.71547652b82fep+0, LOG_P1_LOG2[p1]);
   result += __llvm_libc::fputil::polyeval(dx * dx, c0, c1, c2, c3, c4);
   return result;
 }
 
 // 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;
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GENERIC_EXPLOGXF_H

libc/src/math/generic/inv_trigf_utils.h

 // N[Table[ArcTan[x], {x, 1/8, 8/8, 1/8}], 40]
 extern const double ATAN_T[ATAN_T_SIZE];
 extern const double ATAN_K[5];
 
 // The main idea of the function is to use formula
 // 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.
   FPB::UIntType umin =
       FPB::create_value(false, FPB::EXPONENT_BIAS - ATAN_T_BITS - 1,
                         0x100000000000UL)
           .uintval();
   FPB::UIntType umax =

 //                 [|1, D...|], [0, 0.5]);
 constexpr double ASIN_COEFFS[10] = {0x1.5555555540fa1p-3, 0x1.333333512edc2p-4,
                                     0x1.6db6cc1541b31p-5, 0x1.f1caff324770ep-6,
                                     0x1.6e43899f5f4f4p-6, 0x1.1f847cf652577p-6,
                                     0x1.9b60f47f87146p-7, 0x1.259e2634c494fp-6,
                                     -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]);
   double r2 = fputil::polyeval(x4, ASIN_COEFFS[1], ASIN_COEFFS[3],
                                ASIN_COEFFS[5], ASIN_COEFFS[7], ASIN_COEFFS[9]);
   return fputil::multiply_add(xsq, r2, r1);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GENERIC_INV_TRIGF_UTILS_H

libc/src/math/generic/math_utils.h

 #include "src/__support/common.h"
 #include <errno.h>
 #include <math.h>
 
 #include <stdint.h>
 
 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;
 
 template <> struct XFlowValues<float> {
   static const float OVERFLOW_VALUE;
   static const float UNDERFLOW_VALUE;
   static const float MAY_UNDERFLOW_VALUE;
 };
 
 template <> struct XFlowValues<double> {
   static const double OVERFLOW_VALUE;
   static const double UNDERFLOW_VALUE;
   static const double MAY_UNDERFLOW_VALUE;
 };
 
-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;
 }
 
 template <typename T> struct IsFloatOrDouble {
   static constexpr bool
       Value = // NOLINT so that this Value can match the ones for IsSame
       cpp::is_same_v<T, float> || cpp::is_same_v<T, double>;

 }
 
 template <typename T, EnableIfFloatOrDouble<T> = 0>
 T may_underflow(uint32_t sign) {
   return xflow(sign, XFlowValues<T>::MAY_UNDERFLOW_VALUE);
 }
 
 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);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_MATH_UTILS_H

libc/src/math/generic/range_reduction.h

 //===-- Utilities for trigonometric functions -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MATH_GENERIC_RANGE_REDUCTION_H
 #define LLVM_LIBC_SRC_MATH_GENERIC_RANGE_REDUCTION_H
 
 #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 {
 
 namespace generic {
 
 static constexpr uint32_t FAST_PASS_BOUND = 0x4a80'0000U; // 2^22
 
 static constexpr int N_ENTRIES = 8;

 
 // Exponents of the least significant bits of the corresponding entries in
 // THIRTYTWO_OVER_PI_28.
 static constexpr int THIRTYTWO_OVER_PI_28_LSB_EXP[N_ENTRIES] = {
     -24, -55, -81, -114, -143, -170, -200, -230};
 
 // 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;
   y = fputil::multiply_add(x, THIRTYTWO_OVER_PI_28[1], y);
   y = fputil::multiply_add(x, THIRTYTWO_OVER_PI_28[2], y);
   return static_cast<int64_t>(kd);
 }
 
 // Return k and y, where
 //   k = round(x * 32 / pi) and y = (x * 32 / pi) - k.
 // For large range, there are at most 2 parts of THIRTYTWO_OVER_PI_28
 // 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;
 
   // Skipping the first parts of 32/pi such that:
   //   LSB of x * LSB of THIRTYTWO_OVER_PI_28[i] >= 32.
   while (x_lsb_exp_m4 + THIRTYTWO_OVER_PI_28_LSB_EXP[idx] > 5)
     ++idx;

libc/src/math/generic/range_reduction_fma.h

 //===-- Utilities for trigonometric functions with FMA ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MATH_GENERIC_RANGE_REDUCTION_FMA_H
 #define LLVM_LIBC_SRC_MATH_GENERIC_RANGE_REDUCTION_FMA_H
 
 #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 {
 
 namespace fma {
 
 static constexpr uint32_t FAST_PASS_BOUND = 0x5600'0000U; // 2^45
 
 // Digits of 32/pi, generated by Sollya with:
 // > a0 = D(32/pi);
 // > a1 = D(32/pi - a0);
 // > a2 = D(32/pi - a0 - a1);
 // > a3 = D(32/pi - a0 - a1 - a2);
 static constexpr double THIRTYTWO_OVER_PI[5] = {
     0x1.45f306dc9c883p+3, -0x1.6b01ec5417056p-51, -0x1.6447e493ad4cep-105,
     0x1.e21c820ff28b2p-159, -0x1.508510ea79237p-214};
 
 // 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);
   return static_cast<int64_t>(kd);
 }
 
 // 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]
     // contains at least one integral bit <= 2^5.
     // - When 2^45 <= |x| < 2^55, the lowest 6 unit bits are contained
     // in the last 12 bits of double(x * THIRTYTWO_OVER_PI[0]).
     // - When |x| >= 2^55, the LSB of double(x * THIRTYTWO_OVER_PI[0]) is at
     // least 2^6.

libc/src/math/generic/sincosf_utils.h

const double SIN_K_PI_OVER_32[64] = {
     -0x1.0000000000000p+0, -0x1.fd88da3d12526p-1, -0x1.f6297cff75cbp-1,
     -0x1.e9f4156c62ddap-1, -0x1.d906bcf328d46p-1, -0x1.c38b2f180bdb1p-1,
     -0x1.a9b66290ea1a3p-1, -0x1.8bc806b151741p-1, -0x1.6a09e667f3bcdp-1,
     -0x1.44cf325091dd6p-1, -0x1.1c73b39ae68c8p-1, -0x1.e2b5d3806f63bp-2,
     -0x1.87de2a6aea963p-2, -0x1.294062ed59f06p-2, -0x1.8f8b83c69a60bp-3,
     -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,
   int64_t k;
   double y;
 
   if (likely(x_abs < FAST_PASS_BOUND)) {
     k = small_range_reduction(xd, y);
   } else {
     fputil::FPBits<float> x_bits(x_abs);
     k = large_range_reduction(xd, x_bits.get_exponent(), y);

libc/src/pthread/CMakeLists.txt

DEPENDS
     libc.include.pthread
 )
 
 add_header_library(
   pthread_mutexattr
   HDRS
     pthread_mutexattr.h
   DEPENDS
+    libc.src.__support.common
     libc.include.pthread
 )
 
 add_entrypoint_object(
   pthread_mutexattr_init
   SRCS
     pthread_mutexattr_init.cpp
   HDRS

libc/src/pthread/pthread_mutexattr.h

 //===-- Declarations related mutex attribute objects  -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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 {
 
 enum class PThreadMutexAttrPos : unsigned int {
   TYPE_SHIFT = 0,
   TYPE_MASK = 0x3 << TYPE_SHIFT, // Type is encoded in 2 bits
 
   ROBUST_SHIFT = 2,
   ROBUST_MASK = 0x1 << ROBUST_SHIFT,
 
   PSHARED_SHIFT = 3,
   PSHARED_MASK = 0x1 << PSHARED_SHIFT,
 
   // TODO: Add a mask for protocol and prioceiling when it is supported.
 };
 
 constexpr pthread_mutexattr_t DEFAULT_MUTEXATTR =
     PTHREAD_MUTEX_DEFAULT << unsigned(PThreadMutexAttrPos::TYPE_SHIFT) |
     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);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_H

libc/src/signal/linux/signal_utils.h

 //===-- Internal header for Linux signals -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H
 #define LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H
 
 #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>
 
 namespace __llvm_libc {
 
 // The POSIX definition of struct sigaction and the sigaction data structure
 // expected by the rt_sigaction syscall differ in their definition. So, we
 // define the equivalent of the what the kernel expects to help with making
 // the rt_sigaction syscall.
 //
 // NOTE: Though the kernel definition does not have a union to include the
 // handler taking siginfo_t * argument, one can set sa_handler to sa_sigaction
 // if SA_SIGINFO is set in sa_flags.
 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;
     if (sa_flags & SA_SIGINFO) {
       sa_handler = reinterpret_cast<HandlerType *>(sa.sa_sigaction);
     } else {
       sa_handler = sa.sa_handler;
     }
     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;
     sa.sa_restorer = sa_restorer;
     if (sa_flags & SA_SIGINFO)
       sa.sa_sigaction = reinterpret_cast<SiginfoHandlerType *>(sa_handler);
     else
       sa.sa_handler = sa_handler;
     return sa;
   }
 
   HandlerType *sa_handler;
   unsigned long sa_flags;
   void (*sa_restorer)(void);
   // Our public definition of sigset_t matches that of the kernel's definition.
   // So, we can use the public sigset_t type here.
   sigset_t sa_mask;
 };
 
 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;
   size_t word = n / BITS_PER_SIGWORD;
   size_t bit = n % BITS_PER_SIGWORD;
   set.__signals[word] |= (1UL << bit);
   return true;
 }
 
 // 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;
   size_t word = n / BITS_PER_SIGWORD;
   size_t bit = n % BITS_PER_SIGWORD;
   set.__signals[word] &= ~(1UL << bit);
   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));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H

libc/src/string/CMakeLists.txt

 add_subdirectory(memory_utils)
 
 add_header_library(
   string_utils
   HDRS
     string_utils.h
   DEPENDS
     libc.include.stdlib
     libc.src.__support.CPP.bitset
+    libc.src.__support.common
     .memory_utils.memcpy_implementation
     .memory_utils.bzero_implementation
 )
 
 add_header_library(
   allocating_string_utils
   HDRS
     allocating_string_utils.h

libc/src/string/memory_utils/README.md

 
 Now let's have a look into the `Memset` structure:
 
 ```C++
 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);
       offset += SIZE;
     } while (offset < count - SIZE);
     tail(dst, value, count);
   }
 };

libc/src/string/memory_utils/bzero_implementations.h

 //===-- Implementation of bzero -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BZERO_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memset_implementations.h

 //===-- Implementation of memset and bzero --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H
 #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"
 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 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)
     generic::Memset<1, 1>::block(dst + offset, value);
 }
 
 #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)
     return generic::Memset<1, MaxSize>::block(dst, value);
   if (count == 2)
     return generic::Memset<2, MaxSize>::block(dst, value);
   if (count == 3)
     return generic::Memset<3, MaxSize>::block(dst, value);
inline_memset_x86(Ptr dst, uint8_t value, size_t count) {
   generic::Memset<32, MaxSize>::block(dst, value);
   align_to_next_boundary<32>(dst, count);
   return generic::Memset<32, MaxSize>::loop_and_tail(dst, value, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_X86)
 
 #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;
   if (count <= 3) {
     generic::Memset<1, MaxSize>::block(dst, value);
     if (count > 1)
       generic::Memset<2, MaxSize>::tail(dst, value, count);
     return;
inline_memset_aarch64(Ptr dst, uint8_t value, size_t count) {
   } else {
     generic::Memset<16, MaxSize>::block(dst, value);
     align_to_next_boundary<16>(dst, count);
     return generic::Memset<64, MaxSize>::loop_and_tail(dst, value, 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
                                      : x86::kSse2  ? 16
                                                    : 8;
   return inline_memset_x86<kMaxSize>(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   static constexpr size_t kMaxSize = aarch64::kNeon ? 16 : 8;
   return inline_memset_aarch64<kMaxSize>(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memset_embedded_tiny(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_GPU)
   return inline_memset_embedded_tiny(dst, value, count);
 #else
 #error "Unsupported platform"
 #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);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H

libc/src/string/memory_utils/op_aarch64.h

do {
       offset += SIZE;
     } while (offset < count - SIZE);
     // Unaligned store, we can't use 'dc zva' here.
     static constexpr size_t kMaxSize = kNeon ? 16 : 8;
     generic::Memset<Size, kMaxSize>::tail(dst, value, count);
   }
 };
 
-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.
   // BS, bits [3:0] is log2 of the block count in words.
   // So the next line checks whether the instruction is permitted and block
   // count is 16 words (i.e. 64 bytes).
   return (zva_val & 0b11111) == 0b00100;
 }

libc/src/string/memory_utils/op_builtin.h

 #include "src/string/memory_utils/utils.h"
 
 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
     // The codegen may be suboptimal.
     for (size_t i = 0; i < Size; ++i)
       dst[i] = src[i];
 #endif
   }
 
-  static inline void tail(Ptr __restrict dst, CPtr __restrict src,
+  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,
+  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,
+  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 {
       block(dst + offset, src + offset);
       offset += SIZE;
     } while (offset < count - SIZE);
     tail(dst, src, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memset
 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
     deferred_static_assert("Missing __builtin_memset_inline");
     (void)dst;
     (void)value;
 #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 {
       block(dst + offset, value);
       offset += SIZE;
     } while (offset < count - SIZE);
     tail(dst, value, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Bcmp
 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();
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcmp
 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();
   }
 };
 
 } // namespace __llvm_libc::builtin
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_OP_BUILTIN_H

libc/src/string/memory_utils/op_generic.h

 // Example usage:
 // using MyMap = CTMap<CTPair<1, uint8_t>,
 //                     CTPair<2, uint16_t>,
 //                     >;
 // ...
 // 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...;
   template <size_t I>
   using find_type =
       typename decltype(get_pair(cpp::integral_constant<size_t, I>{}))::type;
 };
 
 // Helper to test if a type is void.
 template <typename T> inline constexpr bool is_void_v = cpp::is_same_v<T, void>;
 
 // Implements load, store and splat for unsigned integral types.
 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);
   }
 };
 
 // GCC can only take literals as __vector_size__ argument so we have to use
 // template specialization.
 template <size_t Size> struct VectorValueType {};
 template <> struct VectorValueType<1> {

 };
 template <> struct VectorValueType<64> {
   using type = uint8_t __attribute__((__vector_size__(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)
       Out[i] = static_cast<uint8_t>(value);
     return Out;
   }
 };
 
#endif                                     //
           CTPair<32, VectorType<32>>,      //
           CTPair<64, VectorType<64>>>;
 
 // Implements load, store and splat for sizes not natively supported by the
 // platform. SubType is either ScalarType or VectorType.
 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);
     return Out;
   }
 };
 
 // Checks whether we should use an ArrayType.

 // platform. For instance on x86 with AVX support this would be 32. If a size
 // greater than MaxSize is requested we break the operation down in smaller
 // pieces of size MaxSize.
 ///////////////////////////////////////////////////////////////////////////////
 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);
     } else {
       using T = getTypeFor<Size, MaxSize>;
       if constexpr (is_void_v<T>) {
         deferred_static_assert("Unimplemented Size");
       } else {
         T::store(dst, T::splat(value));
       }
     }
   }
 
-  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 {
       block(dst + offset, value);
       offset += SIZE;
     } while (offset < count - SIZE);
     tail(dst, value, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Bcmp
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t Size> struct Bcmp {
   static constexpr size_t SIZE = Size;
   static constexpr size_t MaxSize = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
                                         ? 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) {
       return load_xor<uint16_t>(p1, p2);
     } else if constexpr (Size == 4) {
       return load_xor<uint32_t>(p1, p2);
     } else if constexpr (Size == 8) {
       return load_not_equal<uint64_t>(p1, p2);
     } else if constexpr (useArrayType<Size, MaxSize>()) {
       for (size_t offset = 0; offset < Size; offset += MaxSize)
         if (auto value = Bcmp<MaxSize>::block(p1 + offset, p2 + offset))
           return value;
     } else {
       deferred_static_assert("Unimplemented Size");
     }
     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 {
       if (auto value = block(p1 + offset, p2 + offset))
         return value;
       offset += SIZE;
     } while (offset < count - SIZE);
     return tail(p1, p2, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcmp
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t Size> struct Memcmp {
   static constexpr size_t SIZE = Size;
   static constexpr size_t MaxSize = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
                                         ? 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) {
       return load_be_diff<uint16_t>(p1, p2);
     } else if constexpr (Size == 4) {
       return load_be_cmp<uint32_t>(p1, p2);
     } else if constexpr (Size == 8) {
       return load_be_cmp<uint64_t>(p1, p2);
     } else if constexpr (useArrayType<Size, MaxSize>()) {
       for (size_t offset = 0; offset < Size; offset += MaxSize)
         if (Bcmp<MaxSize>::block(p1 + offset, p2 + offset))
           return Memcmp<MaxSize>::block(p1 + offset, p2 + offset);
       return MemcmpReturnType::ZERO();
     } else if constexpr (Size == 3) {
       if (auto value = Memcmp<2>::block(p1, p2))
         return value;
       return Memcmp<1>::block(p1 + 2, p2 + 2);
     } else {
       deferred_static_assert("Unimplemented Size");
     }
   }
 
-  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 {
       if (auto value = block(p1 + offset, p2 + offset))
         return value;
       offset += SIZE;
     } while (offset < count - SIZE);
     return tail(p1, p2, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memmove
 ///////////////////////////////////////////////////////////////////////////////
 
 template <size_t Size, size_t MaxSize> struct Memmove {
   static_assert(is_power2(MaxSize));
   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 {
       T::store(dst, T::load(src));
     }
   }
 
-  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");
     } else {
       // The load and store operations can be performed in any order as long as
       // they are not interleaved. More investigations are needed to determine
       // the best order.
       const auto head = T::load(src);
template <size_t Size, size_t MaxSize> struct Memmove {
   // e.g. Moving two bytes forward, we make sure dst is aligned.
   // [  |       |       |       |      ]
   // [____XXXXXXXXXXXXXXXXXXXXXXXXXXXX_]
   // [____LLLLLLLL_____________________]
   // [______LLLLLLLL___________________]
   // [_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;
     align_to_next_boundary<Size, AlignOn>(dst, src, count);
     adjust(Size, dst, src, count);
     head_tail(prev_dst, prev_src, prev_count - count);
   }
 
template <size_t Size, size_t MaxSize> struct Memmove {
   // e.g. Moving two bytes backward, we make sure dst is aligned.
   // [  |       |       |       |      ]
   // [____XXXXXXXXXXXXXXXXXXXXXXXX_____]
   // [ _______________LLLLLLLL_________]
   // [ ___________________LLLLLLLL_____]
   // [__________________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;
     align_to_next_boundary<Size, AlignOn>(headtail_dst, headtail_src,
                                           headtail_size);
     adjust(-2 * Size, headtail_dst, headtail_src, headtail_size);
     head_tail(headtail_dst, headtail_src, headtail_size);
     count -= headtail_size;
   }
 
   // Move forward suitable when dst < src. We load the tail bytes before
   // handling the loop.
   //
   // e.g. Moving two bytes
   // [   |       |       |       |       |]
   // [___XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX___]
   // [_________________________LLLLLLLL___]
   // [___LLLLLLLL_________________________]
   // [_SSSSSSSS___________________________]
   // [___________LLLLLLLL_________________]
   // [_________SSSSSSSS___________________]
   // [___________________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);
     size_t offset = 0;
     LLVM_LIBC_LOOP_NOUNROLL
     do {
       block(dst + offset, src + offset);
       offset += Size;
template <size_t Size, size_t MaxSize> struct Memmove {
   // [___LLLLLLLL_________________________]
   // [_________________________LLLLLLLL___]
   // [___________________________SSSSSSSS_]
   // [_________________LLLLLLLL___________]
   // [___________________SSSSSSSS_________]
   // [_________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);
     ptrdiff_t offset = count - Size;
     LLVM_LIBC_LOOP_NOUNROLL
     do {
       block(dst + offset, src + offset);
       offset -= Size;
     } while (offset >= 0);
     T::store(dst, head_value);
   }
 };
 
 } // namespace __llvm_libc::generic
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_OP_GENERIC_H

libc/src/string/memory_utils/op_x86.h

 
 // Base implementation for the Bcmp specializations.
 //  - BlockSize is either 16, 32 or 64 depending on the available compile time
 // features, it is used to switch between "single native operation" or a
 // "sequence of native operations".
 //  - 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) {
       for (size_t offset = 0; offset < Size; offset += BlockSize)
         if (auto value = BlockBcmp(p1 + offset, p2 + offset))
           return value;
     } else {
       deferred_static_assert("SIZE not implemented");
     }
     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 {
       if (auto value = block(p1 + offset, p2 + offset))
         return value;
       offset += Size;
     } while (offset < count - Size);
     return tail(p1, p2, count);
   }
 };
 
 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 differ after loading 16 bytes from p1 and p2.
   const int mask =
       _mm_movemask_epi8(cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2)));
   return static_cast<uint32_t>(mask);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__SSE2__)
 }
 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 differ after loading 32 bytes from p1 and p2.
   const int mask =
       _mm256_movemask_epi8(cpp::bit_cast<__m256i>(load<T>(p1) != load<T>(p2)));
   // _mm256_movemask_epi8 returns an int but it is to be interpreted as a 32-bit
   // mask.
   return static_cast<uint32_t>(mask);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__AVX2__)
 }
 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 differ after loading 64 bytes from p1 and p2.
   const uint64_t mask = _mm512_cmpneq_epi8_mask(
       cpp::bit_cast<__m512i>(load<T>(p1)), cpp::bit_cast<__m512i>(load<T>(p2)));
   const bool mask_is_set = mask != 0;
   return static_cast<uint32_t>(mask_is_set);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__AVX512BW__)
 }
 template <size_t Size> using Bcmp = BcmpImpl<Size, 64, bcmp64>;
 } // namespace avx512bw
 
 // 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,
   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]);
   return ca - cb;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcmp
 
 // Base implementation for the Memcmp specializations.
 //  - BlockSize is either 16, 32 or 64 depending on the available compile time
 // features, it is used to switch between "single native operation" or a
 // "sequence of native operations".
 //  - BlockMemcmp is the function that implements the memcmp logic.
 //  - BlockBcmp is the function that implements the bcmp logic.
 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) {
       for (size_t offset = 0; offset < Size; offset += BlockSize)
         if (auto value = BlockBcmp(p1 + offset, p2 + offset))
           return BlockMemcmp(p1 + offset, p2 + offset);
     } else {
       deferred_static_assert("SIZE not implemented");
     }
     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 {
       if (auto value = block(p1 + offset, p2 + offset))
         return value;
       offset += Size;
     } while (offset < count - Size);
     return tail(p1, p2, count);
   }
 };
 
 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 differ after loading 16 bytes from p1 and p2.
   if (int mask =
           _mm_movemask_epi8(cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2))))
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();
 #else
   (void)p1;
   (void)p2;
   return MemcmpReturnType::ZERO();
 #endif // defined(__SSE2__)
 }
 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 differ after loading 32 bytes from p1 and p2.
   if (int mask = _mm256_movemask_epi8(
           cpp::bit_cast<__m256i>(load<T>(p1) != load<T>(p2))))
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();
 #else
   (void)p1;
   (void)p2;
   return MemcmpReturnType::ZERO();
 #endif // defined(__AVX2__)
 }
 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 differ after loading 64 bytes from p1 and p2.
   if (uint64_t mask =
           _mm512_cmpneq_epi8_mask(cpp::bit_cast<__m512i>(load<T>(p1)),
                                   cpp::bit_cast<__m512i>(load<T>(p2))))
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();

libc/src/string/memory_utils/utils.h

 //===-- Memory utils --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MEMORY_UTILS_UTILS_H
 #define LLVM_LIBC_SRC_MEMORY_UTILS_UTILS_H
 
 #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
 #include <stdint.h> // intptr_t / uintptr_t
 
 namespace __llvm_libc {
 
 // Allows compile time error reporting in `if constexpr` branches.

 #endif
 
 #if LLVM_LIBC_HAS_BUILTIN(__builtin_memset_inline)
 #define LLVM_LIBC_HAS_BUILTIN_MEMSET_INLINE
 #endif
 
 // 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,
 #ifdef LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
   __builtin_memcpy_inline(dst, src, Size);
 #else
   for (size_t i = 0; i < Size; ++i)
     static_cast<char *>(dst)[i] = static_cast<const char *>(src)[i];
 #endif
 }
 
template <typename T> struct StrictIntegralType {
   // For interation with the C API we allow explicit conversion back to the
   // `int` type.
   explicit operator int() const {
     // bit_cast makes sure that T and int have the same size.
     return cpp::bit_cast<int>(value);
   }
 
   // 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;
 };
 
 using MemcmpReturnType = StrictIntegralType<int32_t>;
 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(ptrdiff_t offset, T1 *__restrict &p1,
-                          T2 *__restrict &p2, size_t &count) {
+LIBC_INLINE void adjust(ptrdiff_t offset, T1 *__restrict &p1,
   p1 += offset;
   p2 += offset;
   count -= offset;
 }
 
 // Advances p1 and p2 so p1 gets aligned to the next SIZE bytes boundary
 // and decrease count by the same amount.
 // We make sure the compiler knows about the adjusted pointer alignment.

libc/src/string/string_utils.h

template <typename Word> constexpr bool has_zeroes(Word block) {
   constexpr Word LOW_BITS = repeat_byte<Word>(0x01);
   constexpr Word HIGH_BITS = repeat_byte<Word>(0x80);
   Word subtracted = block - LOW_BITS;
   Word inverted = ~block;
   return (subtracted & inverted & HIGH_BITS) != 0;
 }
 
 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;
        ++char_ptr) {
     if (*char_ptr == '\0')
       return char_ptr - src;
   }
   // Step 2: read blocks
   for (const Word *block_ptr = reinterpret_cast<const Word *>(char_ptr);
        !has_zeroes<Word>(*block_ptr); ++block_ptr) {
     char_ptr = reinterpret_cast<const char *>(block_ptr);
   }
   // Step 3: find the zero in the block
   for (; *char_ptr != '\0'; ++char_ptr) {
     ;
   }
   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)
     ;
   return length;
 }
 
 // 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
   // be aligned to a word boundary, so it's the size we use for reading the
   // string a block at a time.
   return string_length_wide_read<unsigned int>(src);
 #else
   return string_length_byte_read(src);
 #endif
 }
 
 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,
   const unsigned char *char_ptr = src;
   size_t cur = 0;
 
   // Step 1: read 1 byte at a time to align to block size
   for (; reinterpret_cast<uintptr_t>(char_ptr) % sizeof(Word) != 0 && cur < n;
        ++char_ptr, ++cur) {
     if (*char_ptr == ch)
       return const_cast<unsigned char *>(char_ptr);
LIBC_INLINE void *find_first_character_wide_read(const unsigned char *src,
   }
 
   if (*char_ptr != ch || cur >= n)
     return static_cast<void *>(nullptr);
 
   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,
   for (; n && *src != ch; --n, ++src)
     ;
   return n ? const_cast<unsigned char *>(src) : nullptr;
 }
 
 // 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,
 #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
   // greater than the gains from reading larger chunks. Based on some testing,
   // the crossover point between when it's faster to just read bytewise and read
   // blocks is somewhere between 16 and 32, so 4 times the size of the block
   // should be in that range.
   // Unsigned int is used for the same reason as in strlen.
   using BlockType = unsigned int;
   if (max_strlen > (sizeof(BlockType) * 4)) {
     return find_first_character_wide_read<BlockType>(src, ch, max_strlen);
   }
 #endif
   return find_first_character_byte_read(src, ch, max_strlen);
 }
 
 // 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;
 
   for (; *segment; ++segment)
     bitset.set(*segment);
   for (; *src && !bitset.test(*src); ++src)
     ;
   return src - initial;
 }
 
 // Given the similarities between strtok and strtok_r, we can implement both
 // using a utility function. On the first call, 'src' is scanned for the
 // first character not found in 'delimiter_string'. Once found, it scans until
 // the first character in the 'delimiter_string' or the null terminator is
 // found. We define this span as a token. The end of the token is appended with
 // a null terminator, and the token is returned. The point where the last token
 // 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,
   // Return nullptr immediately if both src AND saveptr are nullptr
   if (unlikely(src == nullptr && ((src = *saveptr) == nullptr)))
     return nullptr;
 
   cpp::bitset<256> delimiter_set;
   for (; *delimiter_string != '\0'; ++delimiter_string)
     delimiter_set.set(*delimiter_string);
 
if (delimiter_set.test(*src)) {
       ++src;
       break;
     }
   }
   *saveptr = 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 len = internal::string_length(src);
   if (!size)
     return len;
   size_t n = len < size - 1 ? len : size - 1;
   inline_memcpy(dst, src, n);
   inline_bzero(dst + n, size - n);
   return len;
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif //  LIBC_SRC_STRING_STRING_UTILS_H

libc/src/time/time_utils.h

 //===-- Collection of utils for mktime and friends --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_TIME_TIME_UTILS_H
 #define LLVM_LIBC_SRC_TIME_TIME_UTILS_H
 
 #include <stddef.h> // For size_t.
 
 #include "include/errno.h"
 
+#include "src/__support/common.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/time/mktime.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace time_utils {
 
struct TimeConstants {
   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 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,
   if (timeptr == nullptr || buffer == nullptr) {
     invalid_value();
     return nullptr;
   }
   if (timeptr->tm_wday < 0 ||
       timeptr->tm_wday > (TimeConstants::DAYS_PER_WEEK - 1)) {
     invalid_value();
     return nullptr;
if (written_size < 0)
     return nullptr;
   if (static_cast<size_t>(written_size) >= bufferLength) {
     out_of_range();
     return nullptr;
   }
   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) {
     out_of_range();
     return nullptr;
   }
 
   return result;
 }
 
 } // namespace time_utils
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_TIME_TIME_UTILS_H

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

 
 libc_support_library(
     name = "range_reduction",
     hdrs = [
         "src/math/generic/range_reduction.h",
         "src/math/generic/range_reduction_fma.h",
     ],
     deps = [
+        ":__support_common",
         ":__support_fputil_fma",
         ":__support_fputil_fp_bits",
         ":__support_fputil_multiply_add",
         ":__support_fputil_nearest_integer",
         ":libc_root",
     ],
 )