[libc][NFC] Replace static inline and inline annotations with LIBC_INLINE.

[sivachandra]

Summary

This is first of a few patches which will do similar mechanical changes.

LIBC_INLINE is a simple macro which is default defined as just inline.
The idea is that, different downstream contexts can define the macro as
suitable to their use case and context. For example, one can choose to
define LIBC_INLINE as [[clang::internal_linkage]] inline.

[sivachandra]

Fix incorrectly positioned LIBC_INLINE in a few places.

[sivachandra]

Remove an incorrect switch from static inline to LIBC_INLINE on a var decl.

[abrachet]

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

54

I'm seeing build errors. I think these methods should have been kept static. WDYT?

[sivachandra]

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

54

You are correct. The bot isn't showing them!! I will fix this ASAP.

libc/src/__support/CMakeLists.txt

add_header_library(
   HDRS
     str_to_integer.h
   DEPENDS
     .ctype_utils
     .str_to_num_result
     libc.include.errno
     libc.src.errno.errno
     libc.src.__support.CPP.limits
+    libc.src.__support.common
 )
 
 add_header_library(
   integer_to_string
   HDRS
     integer_to_string.h
   DEPENDS
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.type_traits
 )
 
 
 add_header_library(
   float_to_string
   HDRS
     float_to_string.h
     ryu_constants.h
   DEPENDS
     libc.src.__support.CPP.type_traits
     libc.src.__support.FPUtil.fp_bits
+    libc.src.__support.common
 )
 
 add_header_library(
   high_precision_decimal
   HDRS
     high_precision_decimal.h
   DEPENDS
     .str_to_integer
 )
 
 add_header_library(
   str_to_float
   HDRS
     str_to_float.h
+    detailed_powers_of_ten.h
   DEPENDS
     .ctype_utils
     .high_precision_decimal
     .str_to_integer
     .uint128
     libc.include.errno
     libc.src.__support.CPP.limits
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.builtin_wrappers
+    libc.src.__support.common
     libc.src.errno.errno
 )
 
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h

libc/src/__support/CPP/bitset.h

template <size_t NumberOfBits> struct bitset {
   }
 
 private:
   static constexpr size_t BITS_PER_BYTE = 8;
   static constexpr size_t BITS_PER_UNIT = BITS_PER_BYTE * sizeof(size_t);
   static constexpr size_t NUMBER_OF_UNITS =
       (NumberOfBits + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 
-  static inline size_t mask(size_t Index) {
+  static constexpr size_t mask(size_t Index) {
     return size_t{1} << (Index % BITS_PER_UNIT);
   }
   size_t Data[NUMBER_OF_UNITS] = {0};
 };
 
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H

libc/src/__support/FPUtil/BasicOperations.h

 //===-- Basic operations on floating point 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_BASIC_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
 
 #include "FPBits.h"
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T abs(T x) {
+LIBC_INLINE T abs(T x) {
   FPBits<T> bits(x);
   bits.set_sign(0);
   return T(bits);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T fmin(T x, T y) {
+LIBC_INLINE T fmin(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return y;
   } else if (bity.is_nan()) {
     return x;
   } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmin(+0, -0) == -0 == fmin(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with negative sign.
     return (bitx.get_sign() ? x : y);
   } else {
     return (x < y ? x : y);
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T fmax(T x, T y) {
+LIBC_INLINE T fmax(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return y;
   } else if (bity.is_nan()) {
     return x;
   } else if (bitx.get_sign() != bity.get_sign()) {
     // To make sure that fmax(+0, -0) == +0 == fmax(-0, +0), whenever x and
     // y has different signs and both are not NaNs, we return the number
     // with positive sign.
     return (bitx.get_sign() ? y : x);
   } else {
     return (x > y ? x : y);
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T fdim(T x, T y) {
+LIBC_INLINE T fdim(T x, T y) {
   FPBits<T> bitx(x), bity(y);
 
   if (bitx.is_nan()) {
     return x;
   }
 
   if (bity.is_nan()) {
     return y;

libc/src/__support/FPUtil/CMakeLists.txt

 add_header_library(
   nearest_integer_operations
   HDRS
     NearestIntegerOperations.h
   DEPENDS
     .fp_bits
     .fenv_impl
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
     libc.include.math
     libc.include.errno
     libc.src.errno.errno
 )
 
 add_header_library(
   normal_float
   HDRS
HDRS
     ManipulationFunctions.h
   DEPENDS
     .fp_bits
     .nearest_integer_operations
     .normal_float
     .platform_defs
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
     libc.include.math
     libc.include.errno
     libc.src.errno.errno
 )
 
 add_header_library(
   basic_operations
   HDRS
     BasicOperations.h
   DEPENDS
     .fp_bits
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
 )
 
 add_header_library(
   division_and_remainder_operations
   HDRS
     DivisionAndRemainderOperations.h
   DEPENDS
     .fp_bits
     .manipulation_functions
     .normal_float
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
 )
 
 add_header_library(
   except_value_utils
   HDRS
     except_value_utils.h
   DEPENDS
     .fp_bits
     .fenv_impl
     libc.src.__support.CPP.optional
 )
 
 
 add_header_library(
   hypot
   HDRS
     Hypot.h
   DEPENDS
     .basic_operations
     .fenv_impl
     .fp_bits
     libc.src.__support.builtin_wrappers
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
     libc.src.__support.uint128
 )
 
 add_header_library(
   xfloat
   HDRS
     XFloat.h
   DEPENDS

 )
 
 add_header_library(
   polyeval
   HDRS
     PolyEval.h
   DEPENDS
     .multiply_add
+    libc.src.__support.common
 )
 
 add_header_library(
   nearest_integer
   HDRS
     nearest_integer.h
   DEPENDS
     libc.src.__support.common

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

 //===-- Floating point divsion and remainder operations ---------*- 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_DIVISION_AND_REMAINDER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
 
 #include "FPBits.h"
 #include "ManipulationFunctions.h"
 #include "NormalFloat.h"
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 static constexpr int QUOTIENT_LSB_BITS = 3;
 
 // The implementation is a bit-by-bit algorithm which uses integer division
 // to evaluate the quotient and remainder.
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T remquo(T x, T y, int &q) {
+LIBC_INLINE T remquo(T x, T y, int &q) {
   FPBits<T> xbits(x), ybits(y);
   if (xbits.is_nan())
     return x;
   if (ybits.is_nan())
     return y;
   if (xbits.is_inf() || ybits.is_zero())
     return FPBits<T>::build_quiet_nan(1);
 

libc/src/__support/FPUtil/FEnvImpl.h

 //===-- Floating point environment manipulation 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_SUPPORT_FPUTIL_FENVIMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if defined(LLVM_LIBC_ARCH_AARCH64)
 #if defined(__APPLE__)
 #include "aarch64/fenv_darwin_impl.h"
 #else
 #include "aarch64/FEnvImpl.h"
 #endif
 #elif defined(LLVM_LIBC_ARCH_X86)
 #include "x86_64/FEnvImpl.h"
 #else
 #include <fenv.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // All dummy functions silently succeed.
 
-static inline int clear_except(int) { return 0; }
+LIBC_INLINE int clear_except(int) { return 0; }
 
-static inline int test_except(int) { return 0; }
+LIBC_INLINE int test_except(int) { return 0; }
 
-static inline int set_except(int) { return 0; }
+LIBC_INLINE int set_except(int) { return 0; }
 
-static inline int raise_except(int) { return 0; }
+LIBC_INLINE int raise_except(int) { return 0; }
 
-static inline int get_round() { return FE_TONEAREST; }
+LIBC_INLINE int get_round() { return FE_TONEAREST; }
 
-static inline int set_round(int) { return 0; }
+LIBC_INLINE int set_round(int) { return 0; }
 
-static inline int get_env(fenv_t *) { return 0; }
+LIBC_INLINE int get_env(fenv_t *) { return 0; }
 
-static inline int set_env(const fenv_t *) { return 0; }
+LIBC_INLINE int set_env(const fenv_t *) { return 0; }
 
 } // namespace fputil
 } // namespace __llvm_libc
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVIMPL_H

libc/src/__support/FPUtil/FMA.h

 //===-- Common header for FMA implementations -------------------*- 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_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if defined(LIBC_TARGET_HAS_FMA)
 
 #if defined(LLVM_LIBC_ARCH_X86_64)
 #include "x86_64/FMA.h"
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/FMA.h"
 #endif
 
 #else
 // FMA instructions are not available
 #include "generic/FMA.h"
 #include "src/__support/CPP/type_traits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T> static inline T fma(T x, T y, T z) {
+template <typename T> LIBC_INLINE T fma(T x, T y, T z) {
   return generic::fma(x, y, z);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H

libc/src/__support/FPUtil/Hypot.h

 
 #include "BasicOperations.h"
 #include "FEnvImpl.h"
 #include "FPBits.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
-static inline T find_leading_one(T mant, int &shift_length) {
+LIBC_INLINE T find_leading_one(T mant, int &shift_length) {
   shift_length = 0;
   if (mant > 0) {
     shift_length = (sizeof(mant) * 8) - 1 - unsafe_clz(mant);
   }
   return T(1) << shift_length;
 }
 
 } // namespace internal

 //      described above.
 //
 //
 // Special cases:
 //   - HYPOT(x, y) is +Inf if x or y is +Inf or -Inf; else
 //   - HYPOT(x, y) is NaN if x or y is NaN.
 //
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T hypot(T x, T y) {
+LIBC_INLINE T hypot(T x, T y) {
   using FPBits_t = FPBits<T>;
   using UIntType = typename FPBits<T>::UIntType;
   using DUIntType = typename DoubleLength<UIntType>::Type;
 
   FPBits_t x_bits(x), y_bits(y);
 
   if (x_bits.is_inf() || y_bits.is_inf()) {
     return T(FPBits_t::inf());

libc/src/__support/FPUtil/ManipulationFunctions.h

 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 #include <limits.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T frexp(T x, int &exp) {
+LIBC_INLINE T frexp(T x, int &exp) {
   FPBits<T> bits(x);
   if (bits.is_inf_or_nan())
     return x;
   if (bits.is_zero()) {
     exp = 0;
     return x;
   }
 
   NormalFloat<T> normal(bits);
   exp = normal.exponent + 1;
   normal.exponent = -1;
   return normal;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T modf(T x, T &iptr) {
+LIBC_INLINE T modf(T x, T &iptr) {
   FPBits<T> bits(x);
   if (bits.is_zero() || bits.is_nan()) {
     iptr = x;
     return x;
   } else if (bits.is_inf()) {
     iptr = x;
     return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
   } else {
     iptr = trunc(x);
     if (x == iptr) {
       // If x is already an integer value, then return zero with the right
       // sign.
       return bits.get_sign() ? T(FPBits<T>::neg_zero()) : T(FPBits<T>::zero());
     } else {
       return x - iptr;
     }
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T copysign(T x, T y) {
+LIBC_INLINE T copysign(T x, T y) {
   FPBits<T> xbits(x);
   xbits.set_sign(FPBits<T>(y).get_sign());
   return T(xbits);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline int ilogb(T x) {
+LIBC_INLINE int ilogb(T x) {
   // TODO: Raise appropriate floating point exceptions and set errno to the
   // an appropriate error value wherever relevant.
   FPBits<T> bits(x);
   if (bits.is_zero()) {
     return FP_ILOGB0;
   } else if (bits.is_nan()) {
     return FP_ILOGBNAN;
   } else if (bits.is_inf()) {
if (normal.exponent > INT_MAX)
     return INT_MAX;
   else if (normal.exponent < INT_MIN)
     return INT_MIN;
   else
     return normal.exponent;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T logb(T x) {
+LIBC_INLINE T logb(T x) {
   FPBits<T> bits(x);
   if (bits.is_zero()) {
     // TODO(Floating point exception): Raise div-by-zero exception.
     // TODO(errno): POSIX requires setting errno to ERANGE.
     return T(FPBits<T>::neg_inf());
   } else if (bits.is_nan()) {
     return x;
   } else if (bits.is_inf()) {
     // Return positive infinity.
     return T(FPBits<T>::inf());
   }
 
   NormalFloat<T> normal(bits);
   return normal.exponent;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T ldexp(T x, int exp) {
+LIBC_INLINE T ldexp(T x, int exp) {
   FPBits<T> bits(x);
   if (bits.is_zero() || bits.is_inf_or_nan() || exp == 0)
     return x;
 
   // NormalFloat uses int32_t to store the true exponent value. We should ensure
   // that adding |exp| to it does not lead to integer rollover. But, if |exp|
   // value is larger the exponent range for type T, then we can return infinity
   // early. Because the result of the ldexp operation can be a subnormal number,
LIBC_INLINE T ldexp(T x, int exp) {
 
   // For all other values, NormalFloat to T conversion handles it the right way.
   NormalFloat<T> normal(bits);
   normal.exponent += exp;
   return normal;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T nextafter(T from, T to) {
+LIBC_INLINE T nextafter(T from, T to) {
   FPBits<T> from_bits(from);
   if (from_bits.is_nan())
     return from;
 
   FPBits<T> to_bits(to);
   if (to_bits.is_nan())
     return to;
 

libc/src/__support/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
 #include "FEnvImpl.h"
 #include "FPBits.h"
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 #include <errno.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T trunc(T x) {
+LIBC_INLINE T trunc(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity or NaN, return it.
   // If it is zero also we should return it as is, but the logic
   // later in this function takes care of it. But not doing a zero
   // check, we improve the run time of non-zero values.
   if (bits.is_inf_or_nan())
     return x;
LIBC_INLINE T trunc(T x) {
   }
 
   int trim_size = MantissaWidth<T>::VALUE - exponent;
   bits.set_mantissa((bits.get_mantissa() >> trim_size) << trim_size);
   return T(bits);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T ceil(T x) {
+LIBC_INLINE T ceil(T x) {
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
   bool is_neg = bits.get_sign();
   int exponent = bits.get_exponent();
LIBC_INLINE T ceil(T x) {
   // If x is negative, the ceil operation is equivalent to the trunc operation.
   if (is_neg)
     return trunc_value;
 
   return trunc_value + T(1.0);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T floor(T x) {
+LIBC_INLINE T floor(T x) {
   FPBits<T> bits(x);
   if (bits.get_sign()) {
     return -ceil(-x);
   } else {
     return trunc(x);
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T round(T x) {
+LIBC_INLINE T round(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
   bool is_neg = bits.get_sign();
if (!half_bit_set) {
     // same as the trunc value.
     return trunc_value;
   } else {
     return is_neg ? trunc_value - T(1.0) : trunc_value + T(1.0);
   }
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-static inline T round_using_current_rounding_mode(T x) {
+LIBC_INLINE T round_using_current_rounding_mode(T x) {
   using UIntType = typename FPBits<T>::UIntType;
   FPBits<T> bits(x);
 
   // If x is infinity NaN or zero, return it.
   if (bits.is_inf_or_nan() || bits.is_zero())
     return x;
 
   bool is_neg = bits.get_sign();
LIBC_INLINE T round_using_current_rounding_mode(T x) {
   }
 }
 
 namespace internal {
 
 template <typename F, typename I,
           cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
                            int> = 0>
-static inline I rounded_float_to_signed_integer(F x) {
+LIBC_INLINE I rounded_float_to_signed_integer(F x) {
   constexpr I INTEGER_MIN = (I(1) << (sizeof(I) * 8 - 1));
   constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
   FPBits<F> bits(x);
   auto set_domain_error_and_raise_invalid = []() {
     if (math_errhandling & MATH_ERRNO)
       errno = EDOM;
     if (math_errhandling & MATH_ERREXCEPT)
       raise_except(FE_INVALID);
LIBC_INLINE I rounded_float_to_signed_integer(F x) {
   return x;
 }
 
 } // namespace internal
 
 template <typename F, typename I,
           cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
                            int> = 0>
-static inline I round_to_signed_integer(F x) {
+LIBC_INLINE I round_to_signed_integer(F x) {
   return internal::rounded_float_to_signed_integer<F, I>(round(x));
 }
 
 template <typename F, typename I,
           cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
                            int> = 0>
-static inline I round_to_signed_integer_using_current_rounding_mode(F x) {
+LIBC_INLINE I round_to_signed_integer_using_current_rounding_mode(F x) {
   return internal::rounded_float_to_signed_integer<F, I>(
       round_using_current_rounding_mode(x));
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H

libc/src/__support/FPUtil/PolyEval.h

 //===-- Common header for PolyEval implementations --------------*- 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_POLYEVAL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H
 
 #include "multiply_add.h"
+#include "src/__support/common.h"
 
 // Evaluate polynomial using Horner's Scheme:
 // With polyeval(x, a_0, a_1, ..., a_n) = a_n * x^n + ... + a_1 * x + a_0, we
 // evaluated it as:  a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
 // We will use FMA instructions if available.
 // Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
 //   polyeval( x, 4.0, 3.0, 2.0, 1.0 )
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T> static inline T polyeval(T, T a0) { return a0; }
+template <typename T> LIBC_INLINE T polyeval(T, T a0) { return a0; }
 
 template <typename T, typename... Ts>
-static inline T polyeval(T x, T a0, Ts... a) {
+LIBC_INLINE T polyeval(T x, T a0, Ts... a) {
   return multiply_add(x, polyeval(x, a...), a0);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

 //===-- aarch64 floating point env manipulation 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_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_AARCH64) || defined(__APPLE__)
 #error "Invalid include"
 #endif
 
 #include <arm_acle.h>
 #include <fenv.h>
 #include <stdint.h>
struct FEnv {
   static constexpr uint32_t UNDERFLOW = 0x8;
   static constexpr uint32_t INEXACT = 0x10;
 
   // Zero-th bit is the first bit.
   static constexpr uint32_t RoundingControlBitPosition = 22;
   static constexpr uint32_t ExceptionStatusFlagsBitPosition = 0;
   static constexpr uint32_t ExceptionControlFlagsBitPosition = 8;
 
-  static inline uint32_t getStatusValueForExcept(int excepts) {
+  LIBC_INLINE uint32_t getStatusValueForExcept(int excepts) {
     return (excepts & FE_INVALID ? INVALID : 0) |
            (excepts & FE_DIVBYZERO ? DIVBYZERO : 0) |
            (excepts & FE_OVERFLOW ? OVERFLOW : 0) |
            (excepts & FE_UNDERFLOW ? UNDERFLOW : 0) |
            (excepts & FE_INEXACT ? INEXACT : 0);
   }
 
-  static inline int exceptionStatusToMacro(uint32_t status) {
+  LIBC_INLINE int exceptionStatusToMacro(uint32_t status) {
     return (status & INVALID ? FE_INVALID : 0) |
            (status & DIVBYZERO ? FE_DIVBYZERO : 0) |
            (status & OVERFLOW ? FE_OVERFLOW : 0) |
            (status & UNDERFLOW ? FE_UNDERFLOW : 0) |
            (status & INEXACT ? FE_INEXACT : 0);
   }
 
   static uint32_t getControlWord() { return __arm_rsr("fpcr"); }
 
   static void writeControlWord(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
 
   static uint32_t getStatusWord() { return __arm_rsr("fpsr"); }
 
   static void writeStatusWord(uint32_t fpsr) { __arm_wsr("fpsr", fpsr); }
 };
 
-static inline int enable_except(int excepts) {
+LIBC_INLINE int enable_except(int excepts) {
   uint32_t newExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord |= (newExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
-static inline int disable_except(int excepts) {
+LIBC_INLINE int disable_except(int excepts) {
   uint32_t disabledExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord &= ~(disabledExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
-static inline int get_except() {
+LIBC_INLINE int get_except() {
   uint32_t controlWord = FEnv::getControlWord();
   int enabledExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   return FEnv::exceptionStatusToMacro(enabledExcepts);
 }
 
-static inline int clear_except(int excepts) {
+LIBC_INLINE int clear_except(int excepts) {
   uint32_t statusWord = FEnv::getStatusWord();
   uint32_t toClear = FEnv::getStatusValueForExcept(excepts);
   statusWord &= ~(toClear << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
-static inline int test_except(int excepts) {
+LIBC_INLINE int test_except(int excepts) {
   uint32_t toTest = FEnv::getStatusValueForExcept(excepts);
   uint32_t statusWord = FEnv::getStatusWord();
   return FEnv::exceptionStatusToMacro(
       (statusWord >> FEnv::ExceptionStatusFlagsBitPosition) & toTest);
 }
 
-static inline int set_except(int excepts) {
+LIBC_INLINE int set_except(int excepts) {
   uint32_t statusWord = FEnv::getStatusWord();
   uint32_t statusValue = FEnv::getStatusValueForExcept(excepts);
   statusWord |= (statusValue << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
-static inline int raise_except(int excepts) {
+LIBC_INLINE int raise_except(int excepts) {
   float zero = 0.0f;
   float one = 1.0f;
   float largeValue = float(FPBits<float>(FPBits<float>::MAX_NORMAL));
   float smallValue = float(FPBits<float>(FPBits<float>::MIN_NORMAL));
   auto divfunc = [](float a, float b) {
     __asm__ __volatile__("ldr  s0, %0\n\t"
                          "ldr  s1, %1\n\t"
                          "fdiv s0, s0, s1\n\t"
if (toRaise & FEnv::INEXACT) {
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::INEXACT))
       result = -1;
   }
   return result;
 }
 
-static inline int get_round() {
+LIBC_INLINE int get_round() {
   uint32_t roundingMode =
       (FEnv::getControlWord() >> FEnv::RoundingControlBitPosition) & 0x3;
   switch (roundingMode) {
   case FEnv::TONEAREST:
     return FE_TONEAREST;
   case FEnv::DOWNWARD:
     return FE_DOWNWARD;
   case FEnv::UPWARD:
     return FE_UPWARD;
   case FEnv::TOWARDZERO:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
-static inline int set_round(int mode) {
+LIBC_INLINE int set_round(int mode) {
   uint16_t bitValue;
   switch (mode) {
   case FE_TONEAREST:
     bitValue = FEnv::TONEAREST;
     break;
   case FE_DOWNWARD:
     bitValue = FEnv::DOWNWARD;
     break;
LIBC_INLINE int set_round(int mode) {
   uint32_t controlWord = FEnv::getControlWord();
   controlWord &= ~(0x3 << FEnv::RoundingControlBitPosition);
   controlWord |= (bitValue << FEnv::RoundingControlBitPosition);
   FEnv::writeControlWord(controlWord);
 
   return 0;
 }
 
-static inline int get_env(fenv_t *envp) {
+LIBC_INLINE int get_env(fenv_t *envp) {
   FEnv::FPState *state = reinterpret_cast<FEnv::FPState *>(envp);
   state->ControlWord = FEnv::getControlWord();
   state->StatusWord = FEnv::getStatusWord();
   return 0;
 }
 
-static inline int set_env(const fenv_t *envp) {
+LIBC_INLINE int set_env(const fenv_t *envp) {
   if (envp == FE_DFL_ENV) {
     // Default status and control words bits are all zeros so we just
     // write zeros.
     FEnv::writeStatusWord(0);
     FEnv::writeControlWord(0);
     return 0;
   }
   const FEnv::FPState *state = reinterpret_cast<const FEnv::FPState *>(envp);

libc/src/__support/FPUtil/aarch64/fenv_darwin_impl.h

 //===- darwin-aarch64 floating point env manipulation 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_SUPPORT_FPUTIL_AARCH64_FENV_DARWIN_IMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENV_DARWIN_IMPL_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_AARCH64) || !defined(__APPLE__)
 #error "Invalid include"
 #endif
 
 #include <arm_acle.h>
 #include <fenv.h>
 #include <stdint.h>
struct FEnv {
   // Zero-th bit is the first bit.
   static constexpr uint32_t ROUNDING_CONTROL_BIT_POSITION = 22;
 
   // In addition to the 5 floating point exceptions, macOS on arm64 defines
   // another floating point exception: FE_FLUSHTOZERO, which is controlled by
   // __fpcr_flush_to_zero bit in the FPCR register.  This control bit is
   // located in a different place from FE_FLUSHTOZERO status bit relative to
   // the other exceptions.
-  static inline uint32_t exception_value_from_status(int status) {
+  LIBC_INLINE uint32_t exception_value_from_status(int status) {
     return (status & FE_INVALID ? EX_INVALID : 0) |
            (status & FE_DIVBYZERO ? EX_DIVBYZERO : 0) |
            (status & FE_OVERFLOW ? EX_OVERFLOW : 0) |
            (status & FE_UNDERFLOW ? EX_UNDERFLOW : 0) |
            (status & FE_INEXACT ? EX_INEXACT : 0) |
            (status & FE_FLUSHTOZERO ? EX_FLUSHTOZERO : 0);
   }
 
-  static inline uint32_t exception_value_from_control(int control) {
+  LIBC_INLINE uint32_t exception_value_from_control(int control) {
     return (control & __fpcr_trap_invalid ? EX_INVALID : 0) |
            (control & __fpcr_trap_divbyzero ? EX_DIVBYZERO : 0) |
            (control & __fpcr_trap_overflow ? EX_OVERFLOW : 0) |
            (control & __fpcr_trap_underflow ? EX_UNDERFLOW : 0) |
            (control & __fpcr_trap_inexact ? EX_INEXACT : 0) |
            (control & __fpcr_flush_to_zero ? EX_FLUSHTOZERO : 0);
   }
 
-  static inline int exception_value_to_status(uint32_t excepts) {
+  LIBC_INLINE int exception_value_to_status(uint32_t excepts) {
     return (excepts & EX_INVALID ? FE_INVALID : 0) |
            (excepts & EX_DIVBYZERO ? FE_DIVBYZERO : 0) |
            (excepts & EX_OVERFLOW ? FE_OVERFLOW : 0) |
            (excepts & EX_UNDERFLOW ? FE_UNDERFLOW : 0) |
            (excepts & EX_INEXACT ? FE_INEXACT : 0) |
            (excepts & EX_FLUSHTOZERO ? FE_FLUSHTOZERO : 0);
   }
 
-  static inline int exception_value_to_control(uint32_t excepts) {
+  LIBC_INLINE int exception_value_to_control(uint32_t excepts) {
     return (excepts & EX_INVALID ? __fpcr_trap_invalid : 0) |
            (excepts & EX_DIVBYZERO ? __fpcr_trap_divbyzero : 0) |
            (excepts & EX_OVERFLOW ? __fpcr_trap_overflow : 0) |
            (excepts & EX_UNDERFLOW ? __fpcr_trap_underflow : 0) |
            (excepts & EX_INEXACT ? __fpcr_trap_inexact : 0) |
            (excepts & EX_FLUSHTOZERO ? __fpcr_flush_to_zero : 0);
   }
 
   static uint32_t get_control_word() { return __arm_rsr("fpcr"); }
 
   static void set_control_word(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
 
   static uint32_t get_status_word() { return __arm_rsr("fpsr"); }
 
   static void set_status_word(uint32_t fpsr) { __arm_wsr("fpsr", fpsr); }
 };
 
-static inline int enable_except(int excepts) {
+LIBC_INLINE int enable_except(int excepts) {
   uint32_t new_excepts = FEnv::exception_value_from_status(excepts);
   uint32_t control_word = FEnv::get_control_word();
   uint32_t old_excepts = FEnv::exception_value_from_control(control_word);
   if (new_excepts != old_excepts) {
     control_word |= FEnv::exception_value_to_control(new_excepts);
     FEnv::set_control_word(control_word);
   }
   return FEnv::exception_value_to_status(old_excepts);
 }
 
-static inline int disable_except(int excepts) {
+LIBC_INLINE int disable_except(int excepts) {
   uint32_t disabled_excepts = FEnv::exception_value_from_status(excepts);
   uint32_t control_word = FEnv::get_control_word();
   uint32_t old_excepts = FEnv::exception_value_from_control(control_word);
   control_word &= ~FEnv::exception_value_to_control(disabled_excepts);
   FEnv::set_control_word(control_word);
   return FEnv::exception_value_to_status(old_excepts);
 }
 
-static inline int get_except() {
+LIBC_INLINE int get_except() {
   uint32_t control_word = FEnv::get_control_word();
   uint32_t enabled_excepts = FEnv::exception_value_from_control(control_word);
   return FEnv::exception_value_to_status(enabled_excepts);
 }
 
-static inline int clear_except(int excepts) {
+LIBC_INLINE int clear_except(int excepts) {
   uint32_t status_word = FEnv::get_status_word();
   uint32_t except_value = FEnv::exception_value_from_status(excepts);
   status_word &= ~FEnv::exception_value_to_status(except_value);
   FEnv::set_status_word(status_word);
   return 0;
 }
 
-static inline int test_except(int excepts) {
+LIBC_INLINE int test_except(int excepts) {
   uint32_t statusWord = FEnv::get_status_word();
   uint32_t ex_value = FEnv::exception_value_from_status(excepts);
   return statusWord & FEnv::exception_value_to_status(ex_value);
 }
 
-static inline int set_except(int excepts) {
+LIBC_INLINE int set_except(int excepts) {
   uint32_t status_word = FEnv::get_status_word();
   uint32_t new_exceptions = FEnv::exception_value_from_status(excepts);
   status_word |= FEnv::exception_value_to_status(new_exceptions);
   FEnv::set_status_word(status_word);
   return 0;
 }
 
-static inline int raise_except(int excepts) {
+LIBC_INLINE int raise_except(int excepts) {
   float zero = 0.0f;
   float one = 1.0f;
   float large_value = float(FPBits<float>(FPBits<float>::MAX_NORMAL));
   float small_value = float(FPBits<float>(FPBits<float>::MIN_NORMAL));
   auto divfunc = [](float a, float b) {
     __asm__ __volatile__("ldr  s0, %0\n\t"
                          "ldr  s1, %1\n\t"
                          "fdiv s0, s0, s1\n\t"
LIBC_INLINE int raise_except(int excepts) {
   }
   if (to_raise & FEnv::EX_FLUSHTOZERO) {
     // TODO: raise the flush to zero floating point exception.
     result = -1;
   }
   return result;
 }
 
-static inline int get_round() {
+LIBC_INLINE int get_round() {
   uint32_t rounding_mode =
       (FEnv::get_control_word() >> FEnv::ROUNDING_CONTROL_BIT_POSITION) & 0x3;
   switch (rounding_mode) {
   case FEnv::TONEAREST:
     return FE_TONEAREST;
   case FEnv::DOWNWARD:
     return FE_DOWNWARD;
   case FEnv::UPWARD:
     return FE_UPWARD;
   case FEnv::TOWARDZERO:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
-static inline int set_round(int mode) {
+LIBC_INLINE int set_round(int mode) {
   uint16_t bit_value;
   switch (mode) {
   case FE_TONEAREST:
     bit_value = FEnv::TONEAREST;
     break;
   case FE_DOWNWARD:
     bit_value = FEnv::DOWNWARD;
     break;
LIBC_INLINE int set_round(int mode) {
   uint32_t control_word = FEnv::get_control_word();
   control_word &= ~(0x3 << FEnv::ROUNDING_CONTROL_BIT_POSITION);
   control_word |= (bit_value << FEnv::ROUNDING_CONTROL_BIT_POSITION);
   FEnv::set_control_word(control_word);
 
   return 0;
 }
 
-static inline int get_env(fenv_t *envp) {
+LIBC_INLINE int get_env(fenv_t *envp) {
   FEnv::FPState *state = reinterpret_cast<FEnv::FPState *>(envp);
   state->ControlWord = FEnv::get_control_word();
   state->StatusWord = FEnv::get_status_word();
   return 0;
 }
 
-static inline int set_env(const fenv_t *envp) {
+LIBC_INLINE int set_env(const fenv_t *envp) {
   if (envp == FE_DFL_ENV) {
     // Default status and control words bits are all zeros so we just
     // write zeros.
     FEnv::set_status_word(0);
     FEnv::set_control_word(0);
     return 0;
   }
   const FEnv::FPState *state = reinterpret_cast<const FEnv::FPState *>(envp);

libc/src/__support/FPUtil/aarch64/nearest_integer.h

 //===--- Round floating point to nearest integer on aarch64 -----*- 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_AARCH64_NEAREST_INTEGER_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_NEAREST_INTEGER_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_AARCH64)
 #error "Invalid include"
 #endif
 
 namespace __llvm_libc {
 namespace fputil {
 
-static inline float nearest_integer(float x) {
+LIBC_INLINE float nearest_integer(float x) {
   float result;
   __asm__ __volatile__("frintn %s0, %s1\n\t" : "=w"(result) : "w"(x));
   return result;
 }
 
-static inline double nearest_integer(double x) {
+LIBC_INLINE double nearest_integer(double x) {
   double result;
   __asm__ __volatile__("frintn %d0, %d1\n\t" : "=w"(result) : "w"(x));
   return result;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_NEAREST_INTEGER_H

libc/src/__support/FPUtil/generic/FMA.h

 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace generic {
 
-template <typename T> static inline T fma(T x, T y, T z);
+template <typename T> LIBC_INLINE T fma(T x, T y, T z);
 
 // TODO(lntue): Implement fmaf that is correctly rounded to all rounding modes.
 // The implementation below only is only correct for the default rounding mode,
 // round-to-nearest tie-to-even.
 template <> inline float fma<float>(float x, float y, float z) {
   // Product is exact.
   double prod = static_cast<double>(x) * static_cast<double>(y);
   double z_d = static_cast<double>(z);
template <> inline float fma<float>(float x, float y, float z) {
 
   return static_cast<float>(static_cast<double>(bit_sum));
 }
 
 namespace internal {
 
 // Extract the sticky bits and shift the `mantissa` to the right by
 // `shift_length`.
-static inline bool shift_mantissa(int shift_length, UInt128 &mant) {
+LIBC_INLINE bool shift_mantissa(int shift_length, UInt128 &mant) {
   if (shift_length >= 128) {
     mant = 0;
     return true; // prod_mant is non-zero.
   }
   UInt128 mask = (UInt128(1) << shift_length) - 1;
   bool sticky_bits = (mant & mask) != 0;
   mant >>= shift_length;
   return sticky_bits;

libc/src/__support/FPUtil/generic/FMod.h

 // be implemented in another handler.
 // Signaling NaN converted to quiet NaN with FE_INVALID exception.
 //    https://www.open-std.org/JTC1/SC22/WG14/www/docs/n1011.htm
 template <typename T> struct FModExceptionalInputHandler {
 
   static_assert(cpp::is_floating_point_v<T>,
                 "FModCStandardWrapper instantiated with invalid type.");
 
-  static bool PreCheck(T x, T y, T &out) {
+  LIBC_INLINE static bool PreCheck(T x, T y, T &out) {
     using FPB = fputil::FPBits<T>;
     const T quiet_NaN = FPB::build_quiet_nan(0);
     FPB sx(x), sy(y);
     if (likely(!sy.is_zero() && !sy.is_inf_or_nan() && !sx.is_inf_or_nan())) {
       return false;
     }
 
     if (sx.is_nan() || sy.is_nan()) {
template <typename T> struct FModFastMathWrapper {
   static bool PreCheck(T, T, T &) { return false; }
 };
 
 template <typename T> class FModDivisionSimpleHelper {
 private:
   using intU_t = typename FPBits<T>::UIntType;
 
 public:
-  inline constexpr static intU_t execute(int exp_diff, int sides_zeroes_count,
-                                         intU_t m_x, intU_t m_y) {
+  LIBC_INLINE constexpr static intU_t
+  execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
     while (exp_diff > sides_zeroes_count) {
       exp_diff -= sides_zeroes_count;
       m_x <<= sides_zeroes_count;
       m_x %= m_y;
     }
     m_x <<= exp_diff;
     m_x %= m_y;
     return m_x;
   }
 };
 
 template <typename T> class FModDivisionInvMultHelper {
 private:
   using FPB = FPBits<T>;
   using intU_t = typename FPB::UIntType;
 
 public:
-  inline constexpr static intU_t execute(int exp_diff, int sides_zeroes_count,
-                                         intU_t m_x, intU_t m_y) {
+  LIBC_INLINE constexpr static intU_t
+  execute(int exp_diff, int sides_zeroes_count, intU_t m_x, intU_t m_y) {
     if (exp_diff > sides_zeroes_count) {
       intU_t inv_hy = (cpp::numeric_limits<intU_t>::max() / m_y);
       while (exp_diff > sides_zeroes_count) {
         exp_diff -= sides_zeroes_count;
         intU_t hd =
             (m_x * inv_hy) >> (FPB::FloatProp::BIT_WIDTH - sides_zeroes_count);
         m_x <<= sides_zeroes_count;
         m_x -= hd * m_y;

 class FMod {
   static_assert(cpp::is_floating_point_v<T>,
                 "FMod instantiated with invalid type.");
 
 private:
   using FPB = FPBits<T>;
   using intU_t = typename FPB::UIntType;
 
-  inline static constexpr FPB eval_internal(FPB sx, FPB sy) {
+  LIBC_INLINE static constexpr FPB eval_internal(FPB sx, FPB sy) {
 
     if (likely(sx.uintval() <= sy.uintval())) {
       if (sx.uintval() < sy.uintval())
         return sx;        // |x|<|y| return x
       return FPB::zero(); // |x|=|y| return 0.0
     }
 
     int e_x = sx.get_unbiased_exponent();
if (exp_diff == 0)
       return FPB::make_value(m_x, e_y);
 
     /* hx next can't be 0, because hx < hy, hy % 2 == 1 hx * 2^i % hy != 0 */
     m_x = DivisionHelper::execute(exp_diff, sides_zeroes_count, m_x, m_y);
     return FPB::make_value(m_x, e_y);
   }
 
 public:
-  static inline T eval(T x, T y) {
+  LIBC_INLINE static T eval(T x, T y) {
     if (T out; Wrapper::PreCheck(x, y, out))
       return out;
     FPB sx(x), sy(y);
     bool sign = sx.get_sign();
     sx.set_sign(false);
     sy.set_sign(false);
     FPB result = eval_internal(sx, sy);
     result.set_sign(sign);

libc/src/__support/FPUtil/generic/sqrt.h

 
 #if defined(SPECIAL_X86_LONG_DOUBLE)
 template <> struct SpecialLongDouble<long double> {
   static constexpr bool VALUE = true;
 };
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 template <typename T>
-static inline void normalize(int &exponent,
-                             typename FPBits<T>::UIntType &mantissa) {
+LIBC_INLINE void normalize(int &exponent,
   const int shift = unsafe_clz(mantissa) -
                     (8 * sizeof(mantissa) - 1 - MantissaWidth<T>::VALUE);
   exponent -= shift;
   mantissa <<= shift;
 }
 
 #ifdef LONG_DOUBLE_IS_DOUBLE
 template <>

 }
 #endif
 
 } // namespace internal
 
 // Correctly rounded IEEE 754 SQRT for all rounding modes.
 // Shift-and-add algorithm.
 template <typename T>
-static inline cpp::enable_if_t<cpp::is_floating_point_v<T>, T> sqrt(T x) {
+LIBC_INLINE cpp::enable_if_t<cpp::is_floating_point_v<T>, T> sqrt(T x) {
 
   if constexpr (internal::SpecialLongDouble<T>::VALUE) {
     // Special 80-bit long double.
     return x86::sqrt(x);
   } else {
     // IEEE floating points formats.
     using UIntType = typename FPBits<T>::UIntType;
     constexpr UIntType ONE = UIntType(1) << MantissaWidth<T>::VALUE;

libc/src/__support/FPUtil/generic/sqrt_80_bit_long_double.h

const int shift =
       unsafe_clz(static_cast<uint64_t>(mantissa)) -
       (8 * sizeof(uint64_t) - 1 - MantissaWidth<long double>::VALUE);
   exponent -= shift;
   mantissa <<= shift;
 }
 
 // if constexpr statement in sqrt.h still requires x86::sqrt to be declared
 // even when it's not used.
-static inline long double sqrt(long double x);
+LIBC_INLINE long double sqrt(long double x);
 
 // Correctly rounded SQRT for all rounding modes.
 // Shift-and-add algorithm.
 #if defined(SPECIAL_X86_LONG_DOUBLE)
-static inline long double sqrt(long double x) {
+LIBC_INLINE long double sqrt(long double x) {
   using UIntType = typename FPBits<long double>::UIntType;
   constexpr UIntType ONE = UIntType(1)
                            << int(MantissaWidth<long double>::VALUE);
 
   FPBits<long double> bits(x);
 
   if (bits.is_inf_or_nan()) {
     if (bits.get_sign() && (bits.get_mantissa() == 0)) {

libc/src/__support/FPUtil/multiply_add.h

 //===-- Common header for multiply-add implementations ----------*- 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_MULTIPLY_ADD_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_MULTIPLY_ADD_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 // Implement a simple wrapper for multiply-add operation:
 //   multiply_add(x, y, z) = x*y + z
 // which uses FMA instructions to speed up if available.
 
-template <typename T> static inline T multiply_add(T x, T y, T z) {
+template <typename T> LIBC_INLINE T multiply_add(T x, T y, T z) {
   return x * y + z;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #if defined(LIBC_TARGET_HAS_FMA)
 

libc/src/__support/FPUtil/nearest_integer.h

 namespace __llvm_libc {
 namespace fputil {
 
 // This is a fast implementation for rounding to a nearest integer that.
 //
 // Notice that for AARCH64 and x86-64 with SSE4.2 support, we will use their
 // corresponding rounding instruction instead.  And in those cases, the results
 // are rounded to the nearest integer, tie-to-even.
-static inline float nearest_integer(float x) {
+LIBC_INLINE float nearest_integer(float x) {
   if (x < 0x1p24f && x > -0x1p24f) {
     float r = x < 0 ? (x - 0x1.0p23f) + 0x1.0p23f : (x + 0x1.0p23f) - 0x1.0p23f;
     float diff = x - r;
     // The expression above is correct for the default rounding mode, round-to-
     // nearest, tie-to-even.  For other rounding modes, it might be off by 1,
     // which is corrected below.
     if (unlikely(diff > 0.5f))
       return r + 1.0f;
     if (unlikely(diff < -0.5f))
       return r - 1.0f;
     return r;
   }
   return x;
 }
 
-static inline double nearest_integer(double x) {
+LIBC_INLINE double nearest_integer(double x) {
   if (x < 0x1p53 && x > -0x1p53) {
     double r = x < 0 ? (x - 0x1.0p52) + 0x1.0p52 : (x + 0x1.0p52) - 0x1.0p52;
     double diff = x - r;
     // The expression above is correct for the default rounding mode, round-to-
     // nearest, tie-to-even.  For other rounding modes, it might be off by 1,
     // which is corrected below.
     if (unlikely(diff > 0.5))
       return r + 1.0;

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

 // In the x87 control word, they occupy the first 6 bits. In the MXCSR
 // register, they occupy bits 7 to 12.
 static constexpr uint16_t X87_EXCEPTION_CONTROL_BIT_POSITION = 0;
 static constexpr uint16_t X87_EXCEPTION_CONTROL_BIT_POSITION_HIGH = 24;
 static constexpr uint16_t MXCSR_EXCEPTION_CONTOL_BIT_POISTION = 7;
 
 // Exception flags are individual bits in the corresponding registers.
 // So, we just OR the bit values to get the full set of exceptions.
-static inline uint16_t get_status_value_for_except(int excepts) {
+LIBC_INLINE uint16_t get_status_value_for_except(int excepts) {
   // We will make use of the fact that exception control bits are single
   // bit flags in the control registers.
   return (excepts & FE_INVALID ? ExceptionFlags::INVALID_F : 0) |
 #ifdef __FE_DENORM
          (excepts & __FE_DENORM ? ExceptionFlags::DENORMAL_F : 0) |
 #endif // __FE_DENORM
          (excepts & FE_DIVBYZERO ? ExceptionFlags::DIV_BY_ZERO_F : 0) |
          (excepts & FE_OVERFLOW ? ExceptionFlags::OVERFLOW_F : 0) |
          (excepts & FE_UNDERFLOW ? ExceptionFlags::UNDERFLOW_F : 0) |
          (excepts & FE_INEXACT ? ExceptionFlags::INEXACT_F : 0);
 }
 
-static inline int exception_status_to_macro(uint16_t status) {
+LIBC_INLINE int exception_status_to_macro(uint16_t status) {
   return (status & ExceptionFlags::INVALID_F ? FE_INVALID : 0) |
 #ifdef __FE_DENORM
          (status & ExceptionFlags::DENORMAL_F ? __FE_DENORM : 0) |
 #endif // __FE_DENORM
          (status & ExceptionFlags::DIV_BY_ZERO_F ? FE_DIVBYZERO : 0) |
          (status & ExceptionFlags::OVERFLOW_F ? FE_OVERFLOW : 0) |
          (status & ExceptionFlags::UNDERFLOW_F ? FE_UNDERFLOW : 0) |
          (status & ExceptionFlags::INEXACT_F ? FE_INEXACT : 0);
 }
 
 struct X87StateDescriptor {
   uint16_t control_word;
   uint16_t unused1;
   uint16_t status_word;
   uint16_t unused2;
   // TODO: Elaborate the remaining 20 bytes as required.
   uint32_t _[5];
 };
 
-static inline uint16_t get_x87_control_word() {
+LIBC_INLINE uint16_t get_x87_control_word() {
   uint16_t w;
   __asm__ __volatile__("fnstcw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void write_x87_control_word(uint16_t w) {
+LIBC_INLINE void write_x87_control_word(uint16_t w) {
   __asm__ __volatile__("fldcw %0" : : "m"(w) :);
 }
 
-static inline uint16_t get_x87_status_word() {
+LIBC_INLINE uint16_t get_x87_status_word() {
   uint16_t w;
   __asm__ __volatile__("fnstsw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void clear_x87_exceptions() {
+LIBC_INLINE void clear_x87_exceptions() {
   __asm__ __volatile__("fnclex" : : :);
 }
 
-static inline uint32_t get_mxcsr() {
+LIBC_INLINE uint32_t get_mxcsr() {
   uint32_t w;
   __asm__ __volatile__("stmxcsr %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
-static inline void write_mxcsr(uint32_t w) {
+LIBC_INLINE void write_mxcsr(uint32_t w) {
   __asm__ __volatile__("ldmxcsr %0" : : "m"(w) :);
 }
 
-static inline void get_x87_state_descriptor(X87StateDescriptor &s) {
+LIBC_INLINE void get_x87_state_descriptor(X87StateDescriptor &s) {
   __asm__ __volatile__("fnstenv %0" : "=m"(s));
   SANITIZER_MEMORY_INITIALIZED(&s, sizeof(s));
 }
 
-static inline void write_x87_state_descriptor(const X87StateDescriptor &s) {
+LIBC_INLINE void write_x87_state_descriptor(const X87StateDescriptor &s) {
   __asm__ __volatile__("fldenv %0" : : "m"(s) :);
 }
 
-static inline void fwait() { __asm__ __volatile__("fwait"); }
+LIBC_INLINE void fwait() { __asm__ __volatile__("fwait"); }
 
 } // namespace internal
 
-static inline int enable_except(int excepts) {
+LIBC_INLINE int enable_except(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set. That is the reason for all the
   // bit-flip operations below as we need to turn the bits to zero
   // to enable them.
 
   uint16_t bit_mask = internal::get_status_value_for_except(excepts);
 
   uint16_t x87_cw = internal::get_x87_control_word();
LIBC_INLINE int enable_except(int excepts) {
 
   // Since the x87 exceptions and SSE exceptions are independent of each,
   // it doesn't make much sence to report both in the return value. Most
   // often, the standard floating point functions deal with FPU operations
   // so we will retrun only the old x87 exceptions.
   return internal::exception_status_to_macro(old_excepts);
 }
 
-static inline int disable_except(int excepts) {
+LIBC_INLINE int disable_except(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set.
 
   uint16_t bit_mask = internal::get_status_value_for_except(excepts);
 
   uint16_t x87_cw = internal::get_x87_control_word();
   uint16_t old_excepts = ~x87_cw & 0x3F; // Save previously enabled exceptions.
   x87_cw |= bit_mask;
   internal::write_x87_control_word(x87_cw);
 
   // Just like in enable_except, it is not clear if disabling SSE exceptions
   // is required. But, we will still do it only as a "nice thing to do".
   uint32_t mxcsr = internal::get_mxcsr();
   mxcsr |= (bit_mask << internal::MXCSR_EXCEPTION_CONTOL_BIT_POISTION);
   internal::write_mxcsr(mxcsr);
 
   return internal::exception_status_to_macro(old_excepts);
 }
 
-static inline int get_except() {
+LIBC_INLINE int get_except() {
   uint16_t mxcsr = static_cast<uint16_t>(internal::get_mxcsr());
   uint16_t enabled_excepts = ~(mxcsr >> 7) & 0x3F;
   return internal::exception_status_to_macro(enabled_excepts);
 }
 
-static inline int clear_except(int excepts) {
+LIBC_INLINE int clear_except(int excepts) {
   internal::X87StateDescriptor state;
   internal::get_x87_state_descriptor(state);
   state.status_word &=
       static_cast<uint16_t>(~internal::get_status_value_for_except(excepts));
   internal::write_x87_state_descriptor(state);
 
   uint32_t mxcsr = internal::get_mxcsr();
   mxcsr &= ~internal::get_status_value_for_except(excepts);
   internal::write_mxcsr(mxcsr);
   return 0;
 }
 
-static inline int test_except(int excepts) {
+LIBC_INLINE int test_except(int excepts) {
   uint16_t status_value = internal::get_status_value_for_except(excepts);
   // Check both x87 status word and MXCSR.
   return internal::exception_status_to_macro(
       static_cast<uint16_t>(status_value & internal::get_mxcsr()));
 }
 
 // Sets the exception flags but does not trigger the exception handler.
-static inline int set_except(int excepts) {
+LIBC_INLINE int set_except(int excepts) {
   uint16_t status_value = internal::get_status_value_for_except(excepts);
   internal::X87StateDescriptor state;
   internal::get_x87_state_descriptor(state);
   state.status_word |= status_value;
   internal::write_x87_state_descriptor(state);
 
   uint32_t mxcsr = internal::get_mxcsr();
   mxcsr |= status_value;
   internal::write_mxcsr(mxcsr);
 
   return 0;
 }
 
-static inline int raise_except(int excepts) {
+LIBC_INLINE int raise_except(int excepts) {
   uint16_t status_value = internal::get_status_value_for_except(excepts);
 
   // We set the status flag for exception one at a time and call the
   // fwait instruction to actually get the processor to raise the
   // exception by calling the exception handler. This scheme is per
   // the description in in "8.6 X87 FPU EXCEPTION SYNCHRONIZATION"
   // of the "Intel 64 and IA-32 Architectures Software Developer's
   // Manual, Vol 1".
#endif // __FE_DENORM
   // There is no special synchronization scheme available to
   // raise SEE exceptions. So, we will ignore that for now.
   // Just plain writing to the MXCSR register does not guarantee
   // the exception handler will be called.
 
   return 0;
 }
 
-static inline int get_round() {
+LIBC_INLINE int get_round() {
   uint16_t bit_value =
       (internal::get_mxcsr() >> internal::MXCSR_ROUNDING_CONTROL_BIT_POSITION) &
       0x3;
   switch (bit_value) {
   case internal::RoundingControlValue::TO_NEAREST:
     return FE_TONEAREST;
   case internal::RoundingControlValue::DOWNWARD:
     return FE_DOWNWARD;
   case internal::RoundingControlValue::UPWARD:
     return FE_UPWARD;
   case internal::RoundingControlValue::TOWARD_ZERO:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
-static inline int set_round(int mode) {
+LIBC_INLINE int set_round(int mode) {
   uint16_t bit_value;
   switch (mode) {
   case FE_TONEAREST:
     bit_value = internal::RoundingControlValue::TO_NEAREST;
     break;
   case FE_DOWNWARD:
     bit_value = internal::RoundingControlValue::DOWNWARD;
     break;
/*
     overflow    div by 0
     underflow   denormal
     inexact     invalid
 
     This is almost reverse, except for denormal and invalid which are in the
     same order in both.
   */
 
-static inline int get_env(fenv_t *envp) {
+LIBC_INLINE int get_env(fenv_t *envp) {
   internal::FPState *state = reinterpret_cast<internal::FPState *>(envp);
 
   uint32_t status_word = 0;
   uint32_t control_word = 0;
 
   uint32_t mxcsr = internal::get_mxcsr();
 
   // Set exception flags in the status word
LIBC_INLINE int get_env(fenv_t *envp) {
   // Set denormals-are-zero xor flush-to-zero in bit 11
   control_word |= (((mxcsr & 0x8000) >> 9) ^ (mxcsr & 0x0040)) << 5;
 
   state->control_word = control_word;
   state->status_word = status_word;
   return 0;
 }
 
-static inline int set_env(const fenv_t *envp) {
+LIBC_INLINE int set_env(const fenv_t *envp) {
   const internal::FPState *state =
       reinterpret_cast<const internal::FPState *>(envp);
 
   uint32_t mxcsr = 0;
 
   // Set exception flags from the status word
   mxcsr |= static_cast<uint16_t>(
       (state->status_word &
LIBC_INLINE int set_env(const fenv_t *envp) {
 
   // Set flush-to-zero from bit 10
   mxcsr |= static_cast<uint16_t>((state->control_word & 0x400) << 5);
 
   internal::write_mxcsr(mxcsr);
   return 0;
 }
 #else
-static inline int get_env(fenv_t *envp) {
+LIBC_INLINE int get_env(fenv_t *envp) {
   internal::FPState *state = reinterpret_cast<internal::FPState *>(envp);
   internal::get_x87_state_descriptor(state->x87_status);
   state->mxcsr = internal::get_mxcsr();
   return 0;
 }
 
-static inline int set_env(const fenv_t *envp) {
+LIBC_INLINE int set_env(const fenv_t *envp) {
   // envp contains everything including pieces like the current
   // top of FPU stack. We cannot arbitrarily change them. So, we first
   // read the current status and update only those pieces which are
   // not disruptive.
   internal::X87StateDescriptor x87_status;
   internal::get_x87_state_descriptor(x87_status);
 
   if (envp == FE_DFL_ENV) {

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

 //===-- x86_64 implementations of the fma function --------------*- 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_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86_64)
 #error "Invalid include"
 #endif
 
 #if !defined(LIBC_TARGET_HAS_FMA)
 #error "FMA instructions are not supported"
 #endif
 
 #include "src/__support/CPP/type_traits.h"
 #include <immintrin.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
-static inline cpp::enable_if_t<cpp::is_same_v<T, float>, T> fma(T x, T y, T z) {
+LIBC_INLINE cpp::enable_if_t<cpp::is_same_v<T, float>, T> fma(T x, T y, T z) {
   float result;
   __m128 xmm = _mm_load_ss(&x);           // NOLINT
   __m128 ymm = _mm_load_ss(&y);           // NOLINT
   __m128 zmm = _mm_load_ss(&z);           // NOLINT
   __m128 r = _mm_fmadd_ss(xmm, ymm, zmm); // NOLINT
   _mm_store_ss(&result, r);               // NOLINT
   return result;
 }
 
 template <typename T>
-static inline cpp::enable_if_t<cpp::is_same_v<T, double>, T> fma(T x, T y,
-                                                                 T z) {
+LIBC_INLINE cpp::enable_if_t<cpp::is_same_v<T, double>, T> fma(T x, T y, T z) {
   double result;
   __m128d xmm = _mm_load_sd(&x);           // NOLINT
   __m128d ymm = _mm_load_sd(&y);           // NOLINT
   __m128d zmm = _mm_load_sd(&z);           // NOLINT
   __m128d r = _mm_fmadd_sd(xmm, ymm, zmm); // NOLINT
   _mm_store_sd(&result, r);                // NOLINT
   return result;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H

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

 #include "src/__support/CPP/bit.h"
 #include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
-static inline long double nextafter(long double from, long double to) {
+LIBC_INLINE long double nextafter(long double from, long double to) {
   using FPBits = FPBits<long double>;
   FPBits from_bits(from);
   if (from_bits.is_nan())
     return from;
 
   FPBits to_bits(to);
   if (to_bits.is_nan())
     return to;

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

 //===--- Round floating point to nearest integer on x86-64 ------*- 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_NEAREST_INTEGER_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEAREST_INTEGER_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86_64)
 #error "Invalid include"
 #endif
 
 #if !defined(__SSE4_2__)
 #error "SSE4.2 instruction set is not supported"
 #endif
 
 #include <immintrin.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
-static inline float nearest_integer(float x) {
+LIBC_INLINE float nearest_integer(float x) {
   __m128 xmm = _mm_set_ss(x); // NOLINT
   __m128 ymm =
       _mm_round_ss(xmm, xmm, _MM_ROUND_NEAREST | _MM_FROUND_NO_EXC); // NOLINT
   return ymm[0];
 }
 
-static inline double nearest_integer(double x) {
+LIBC_INLINE double nearest_integer(double x) {
   __m128d xmm = _mm_set_sd(x); // NOLINT
   __m128d ymm =
       _mm_round_sd(xmm, xmm, _MM_ROUND_NEAREST | _MM_FROUND_NO_EXC); // NOLINT
   return ymm[0];
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEAREST_INTEGER_H

libc/src/__support/OSUtil/linux/io.h

 
 #include "src/string/string_utils.h"
 #include "syscall.h" // For internal syscall function.
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
-static inline void write_to_stderr(const char *msg) {
+LIBC_INLINE void write_to_stderr(const char *msg) {
   __llvm_libc::syscall_impl(SYS_write, 2 /* stderr */, msg,
                             internal::string_length(msg));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_IO_H

libc/src/__support/OSUtil/linux/quick_exit.h

 //===---------- Linux implementation of a quick exit function ---*- 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_OSUTIL_LINUX_QUICK_EXIT_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_QUICK_EXIT_H
 
 #include "syscall.h"             // For internal syscall function.
 
+#include "src/__support/common.h"
+
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
-static inline void quick_exit(int status) {
+LIBC_INLINE void quick_exit(int status) {
   for (;;) {
     __llvm_libc::syscall_impl(SYS_exit_group, status);
     __llvm_libc::syscall_impl(SYS_exit, status);
   }
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_QUICK_EXIT_H

libc/src/__support/builtin_wrappers.h

 //===--Convenient template for builtins -------------------------*- C++ -*-===//
 //             (Count Lead Zeroes) and (Count Trailing Zeros)
 //
 // 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_BUILTIN_WRAPPERS_H
 #define LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H
 
 #include "named_pair.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 #include "src/__support/compiler_features.h"
 
 namespace __llvm_libc {
 
 // The following overloads are matched based on what is accepted by
 // __builtin_clz/ctz* rather than using the exactly-sized aliases from stdint.h.
 // This way, we can avoid making any assumptions about integer sizes and let the
 // compiler match for us.
 namespace __internal {
 
-template <typename T> static inline int correct_zero(T val, int bits) {
+template <typename T> LIBC_INLINE int correct_zero(T val, int bits) {
   if (val == T(0))
     return sizeof(T(0)) * 8;
   else
     return bits;
 }
 
-template <typename T> static inline int clz(T val);
+template <typename T> LIBC_INLINE int clz(T val);
 template <> inline int clz<unsigned int>(unsigned int val) {
   return __builtin_clz(val);
 }
 template <> inline int clz<unsigned long int>(unsigned long int val) {
   return __builtin_clzl(val);
 }
 template <> inline int clz<unsigned long long int>(unsigned long long int val) {
   return __builtin_clzll(val);
 }
 
-template <typename T> static inline int ctz(T val);
+template <typename T> LIBC_INLINE int ctz(T val);
 template <> inline int ctz<unsigned int>(unsigned int val) {
   return __builtin_ctz(val);
 }
 template <> inline int ctz<unsigned long int>(unsigned long int val) {
   return __builtin_ctzl(val);
 }
 template <> inline int ctz<unsigned long long int>(unsigned long long int val) {
   return __builtin_ctzll(val);
 }
 } // namespace __internal
 
-template <typename T> static inline int safe_ctz(T val) {
+template <typename T> LIBC_INLINE int safe_ctz(T val) {
   return __internal::correct_zero(val, __internal::ctz(val));
 }
 
-template <typename T> static inline int unsafe_ctz(T val) {
+template <typename T> LIBC_INLINE int unsafe_ctz(T val) {
   return __internal::ctz(val);
 }
 
-template <typename T> static inline int safe_clz(T val) {
+template <typename T> LIBC_INLINE int safe_clz(T val) {
   return __internal::correct_zero(val, __internal::clz(val));
 }
 
-template <typename T> static inline int unsafe_clz(T val) {
+template <typename T> LIBC_INLINE int unsafe_clz(T val) {
   return __internal::clz(val);
 }
 
 // Add with carry
 DEFINE_NAMED_PAIR_TEMPLATE(SumCarry, sum, carry);
 
 template <typename T>
 inline constexpr cpp::enable_if_t<

libc/src/__support/common.h

 #ifndef UNUSED
 #define UNUSED __attribute__((unused))
 #endif
 
 #ifndef LLVM_LIBC_FUNCTION_ATTR
 #define LLVM_LIBC_FUNCTION_ATTR
 #endif
 
+#ifndef LIBC_INLINE
+#define LIBC_INLINE inline
+#endif
+
 // We use OpenMP to declare these functions on the device.
 #define STR(X) #X
 #define LLVM_LIBC_DECLARE_DEVICE(name)                                         \
   _Pragma(STR(omp declare target to(name) device_type(nohost)))
 
 // GPU targets do not support aliasing and must be declared on the device.
 #if defined(LLVM_LIBC_PUBLIC_PACKAGING) && defined(_OPENMP)
 #define LLVM_LIBC_FUNCTION(type, name, arglist)                                \

libc/src/__support/detailed_powers_of_ten.h

 //===-- detailed powers of ten ----------------------------------*- 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 LIBC_SRC_SUPPORT_DETAILED_POWERS_OF_TEN_H
 #define LIBC_SRC_SUPPORT_DETAILED_POWERS_OF_TEN_H
 
+#include "src/__support/common.h"
+
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // TODO(michaelrj): write a script that will generate this table.
 
 // This table was generated by
 // https://github.com/google/wuffs/blob/788479dd64f35cb6b4e998a851acb06ee962435b/script/print-mpb-powers-of-10.go
 // and contains the 128 bit mantissa approximations of the powers of 10 from
 // -348 to 347. The exponents are implied by a linear expression with slope
 // 217706.0/65536.0 ≈ log(10)/log(2). This is used by the Eisel-Lemire algorithm
 // in str_to_float.h.
 
 constexpr int32_t DETAILED_POWERS_OF_TEN_MIN_EXP_10 = -348;
 constexpr int32_t DETAILED_POWERS_OF_TEN_MAX_EXP_10 = 347;
 
 // This rescales the base 10 exponent by a factor of log(10)/log(2).
-static inline int64_t exp10_to_exp2(int64_t exp10) {
+LIBC_INLINE int64_t exp10_to_exp2(int64_t exp10) {
   return (217706 * exp10) >> 16;
 }
 
 static constexpr uint64_t DETAILED_POWERS_OF_TEN[696][2] = {
     {0x1732C869CD60E453, 0xFA8FD5A0081C0288}, // 1e-348
     {0x0E7FBD42205C8EB4, 0x9C99E58405118195}, // 1e-347
     {0x521FAC92A873B261, 0xC3C05EE50655E1FA}, // 1e-346
     {0xE6A797B752909EF9, 0xF4B0769E47EB5A78}, // 1e-345

libc/src/__support/float_to_string.h

 //===-- Utilities to convert floating point values to string ----*- 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_FLOAT_TO_STRING_H
 #define LLVM_LIBC_SRC_SUPPORT_FLOAT_TO_STRING_H
 
 #include <stdint.h>
 
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/UInt.h"
+#include "src/__support/common.h"
 #include "src/__support/ryu_constants.h"
 
 // This implementation is based on the Ryu Printf algorithm by Ulf Adams:
 // Ulf Adams. 2019. Ryū revisited: printf floating point conversion.
 // Proc. ACM Program. Lang. 3, OOPSLA, Article 169 (October 2019), 23 pages.
 // https://doi.org/10.1145/3360595
 
 // This version is modified to require significantly less memory (it doesn't use
if (shift_amount > 0) {
     num = num >> (-shift_amount);
   }
   // if (num > MOD_SIZE) {
   //   num = num % MOD_SIZE;
   // }
   return num;
 }
 
-static inline uint32_t fast_uint_mod_1e9(const cpp::UInt<MID_INT_SIZE> &val) {
+LIBC_INLINE uint32_t fast_uint_mod_1e9(const cpp::UInt<MID_INT_SIZE> &val) {
   // The formula for mult_const is:
   //  1 + floor((2^(bits in target integer size + log_2(divider))) / divider)
   // Where divider is 10^9 and target integer size is 128.
   const cpp::UInt<MID_INT_SIZE> mult_const(
       {0x31680A88F8953031u, 0x89705F4136B4A597u, 0});
   const auto middle = (mult_const * val);
   const uint64_t result = static_cast<uint64_t>(middle[2]);
   const uint32_t shifted = result >> 29;
   return static_cast<uint32_t>(val) - (1000000000 * shifted);
 }
 
-static inline uint32_t mul_shift_mod_1e9(const MantissaInt mantissa,
-                                         const cpp::UInt<MID_INT_SIZE> &large,
-                                         const int32_t shift_amount) {
+LIBC_INLINE uint32_t mul_shift_mod_1e9(const MantissaInt mantissa,
   constexpr size_t MANT_INT_SIZE = sizeof(MantissaInt) * 8;
   cpp::UInt<MID_INT_SIZE + MANT_INT_SIZE> val(large);
   // TODO: Find a better way to force __uint128_t to be UInt<128>
   cpp::UInt<MANT_INT_SIZE> wide_mant(0);
   wide_mant[0] = mantissa & (uint64_t(-1));
   wide_mant[1] = mantissa >> 64;
   val = (val * wide_mant) >> shift_amount;
   return fast_uint_mod_1e9(val);

libc/src/__support/str_to_float.h

 //===-- String to float conversion 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 LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 #define LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
+#include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include <errno.h>
 
 namespace __llvm_libc {
 namespace internal {
 
-template <class T> uint32_t inline leading_zeroes(T inputNumber) {
+template <class T> LIBC_INLINE uint32_t leading_zeroes(T inputNumber) {
   constexpr uint32_t BITS_IN_T = sizeof(T) * 8;
   if (inputNumber == 0) {
     return BITS_IN_T;
   }
   uint32_t cur_guess = BITS_IN_T / 2;
   uint32_t range_size = BITS_IN_T / 2;
   // while either shifting by curGuess does not get rid of all of the bits or
   // shifting by one less also gets rid of all of the bits then we have not
while (((inputNumber >> cur_guess) > 0) ||
     }
   }
   if (inputNumber >> cur_guess > 0) {
     cur_guess++;
   }
   return BITS_IN_T - cur_guess;
 }
 
-template <> uint32_t inline leading_zeroes<uint32_t>(uint32_t inputNumber) {
+template <>
+LIBC_INLINE uint32_t leading_zeroes<uint32_t>(uint32_t inputNumber) {
   return safe_clz(inputNumber);
 }
 
-template <> uint32_t inline leading_zeroes<uint64_t>(uint64_t inputNumber) {
+template <>
+LIBC_INLINE uint32_t leading_zeroes<uint64_t>(uint64_t inputNumber) {
   return safe_clz(inputNumber);
 }
 
-static inline uint64_t low64(const UInt128 &num) {
+LIBC_INLINE uint64_t low64(const UInt128 &num) {
   return static_cast<uint64_t>(num & 0xffffffffffffffff);
 }
 
-static inline uint64_t high64(const UInt128 &num) {
+LIBC_INLINE uint64_t high64(const UInt128 &num) {
   return static_cast<uint64_t>(num >> 64);
 }
 
-template <class T> inline void set_implicit_bit(fputil::FPBits<T> &) { return; }
+template <class T> LIBC_INLINE void set_implicit_bit(fputil::FPBits<T> &) {
+  return;
+}
 
 #if defined(SPECIAL_X86_LONG_DOUBLE)
 template <>
 inline void set_implicit_bit<long double>(fputil::FPBits<long double> &result) {
   result.set_implicit_bit(result.get_unbiased_exponent() != 0);
 }
 #endif
 
 // This Eisel-Lemire implementation is based on the algorithm described in the
 // paper Number Parsing at a Gigabyte per Second, Software: Practice and
 // Experience 51 (8), 2021 (https://arxiv.org/abs/2101.11408), as well as the
 // description by Nigel Tao
 // (https://nigeltao.github.io/blog/2020/eisel-lemire.html) and the golang
 // implementation, also by Nigel Tao
 // (https://github.com/golang/go/blob/release-branch.go1.16/src/strconv/eisel_lemire.go#L25)
 // for some optimizations as well as handling 32 bit floats.
 template <class T>
-static inline bool
+LIBC_INLINE bool
 eisel_lemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
              typename fputil::FPBits<T>::UIntType *outputMantissa,
              uint32_t *outputExp2) {
 
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BITS_IN_MANTISSA = sizeof(mantissa) * 8;
 
   if (sizeof(T) > 8) { // This algorithm cannot handle anything longer than a
constexpr int32_t NUM_POWERS_OF_TWO =
     sizeof(POWERS_OF_TWO) / sizeof(POWERS_OF_TWO[0]);
 
 // Takes a mantissa and base 10 exponent and converts it into its closest
 // floating point type T equivalent. This is the fallback algorithm used when
 // the Eisel-Lemire algorithm fails, it's slower but more accurate. It's based
 // on the Simple Decimal Conversion algorithm by Nigel Tao, described at this
 // link: https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
 template <class T>
-static inline void
+LIBC_INLINE void
 simple_decimal_conversion(const char *__restrict numStart,
                           typename fputil::FPBits<T>::UIntType *outputMantissa,
                           uint32_t *outputExp2) {
 
   int32_t exp2 = 0;
   HighPrecisionDecimal hpd = HighPrecisionDecimal(numStart);
 
   if (hpd.get_num_digits() == 0) {

 };
 #endif
 
 // Take an exact mantissa and exponent and attempt to convert it using only
 // exact floating point arithmetic. This only handles numbers with low
 // exponents, but handles them quickly. This is an implementation of Clinger's
 // Fast Path, as described above.
 template <class T>
-static inline bool
+LIBC_INLINE bool
 clinger_fast_path(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
                   typename fputil::FPBits<T>::UIntType *outputMantissa,
                   uint32_t *outputExp2) {
   if (mantissa >> fputil::FloatProperties<T>::MANTISSA_WIDTH > 0) {
     return false;
   }
 
   fputil::FPBits<T> result;

 }
 
 // Takes a mantissa and base 10 exponent and converts it into its closest
 // floating point type T equivalient. First we try the Eisel-Lemire algorithm,
 // then if that fails then we fall back to a more accurate algorithm for
 // accuracy. The resulting mantissa and exponent are placed in outputMantissa
 // and outputExp2.
 template <class T>
-static inline void
+LIBC_INLINE void
 decimal_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa,
                      int32_t exp10, const char *__restrict numStart,
                      bool truncated,
                      typename fputil::FPBits<T>::UIntType *outputMantissa,
                      uint32_t *outputExp2) {
   // If the exponent is too large and can't be represented in this size of
   // float, return inf. These bounds are relatively loose, but are mostly
   // serving as a first pass. Some close numbers getting through is okay.
#endif // LLVM_LIBC_DISABLE_SIMPLE_DECIMAL_CONVERSION
   return;
 }
 
 // Takes a mantissa and base 2 exponent and converts it into its closest
 // floating point type T equivalient. Since the exponent is already in the right
 // form, this is mostly just shifting and rounding. This is used for hexadecimal
 // numbers since a base 16 exponent multiplied by 4 is the base 2 exponent.
 template <class T>
-static inline void
+LIBC_INLINE void
 binary_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
                     bool truncated,
                     typename fputil::FPBits<T>::UIntType *outputMantissa,
                     uint32_t *outputExp2) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
 
   // This is the number of leading zeroes a properly normalized float of type T
   // should have.
binary_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp2,
   }
 
   *outputMantissa = mantissa & fputil::FloatProperties<T>::MANTISSA_MASK;
   *outputExp2 = biased_exponent;
 }
 
 // checks if the next 4 characters of the string pointer are the start of a
 // hexadecimal floating point number. Does not advance the string pointer.
-static inline bool is_float_hex_start(const char *__restrict src,
-                                      const char decimalPoint) {
+LIBC_INLINE bool is_float_hex_start(const char *__restrict src,
   if (!(*src == '0' && (*(src + 1) | 32) == 'x')) {
     return false;
   }
   if (*(src + 2) == decimalPoint) {
     return isalnum(*(src + 3)) && b36_char_to_int(*(src + 3)) < 16;
   } else {
     return isalnum(*(src + 2)) && b36_char_to_int(*(src + 2)) < 16;
   }
 }
 
 // Takes the start of a string representing a decimal float, as well as the
 // local decimalPoint. It returns if it suceeded in parsing any digits, and if
 // the return value is true then the outputs are pointer to the end of the
 // number, and the mantissa and exponent for the closest float T representation.
 // If the return value is false, then it is assumed that there is no number
 // here.
 template <class T>
-static inline bool
+LIBC_INLINE bool
 decimal_string_to_float(const char *__restrict src, const char DECIMAL_POINT,
                         char **__restrict strEnd,
                         typename fputil::FPBits<T>::UIntType *outputMantissa,
                         uint32_t *outputExponent) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BASE = 10;
   constexpr char EXPONENT_MARKER = 'e';
 

 
 // Takes the start of a string representing a hexadecimal float, as well as the
 // local decimal point. It returns if it suceeded in parsing any digits, and if
 // the return value is true then the outputs are pointer to the end of the
 // number, and the mantissa and exponent for the closest float T representation.
 // If the return value is false, then it is assumed that there is no number
 // here.
 template <class T>
-static inline bool hexadecimal_string_to_float(
+LIBC_INLINE bool hexadecimal_string_to_float(
     const char *__restrict src, const char DECIMAL_POINT,
     char **__restrict strEnd,
     typename fputil::FPBits<T>::UIntType *outputMantissa,
     uint32_t *outputExponent) {
   using BitsType = typename fputil::FPBits<T>::UIntType;
   constexpr uint32_t BASE = 16;
   constexpr char EXPONENT_MARKER = 'p';
 
binary_exp_to_float<T>(mantissa, exponent, truncated, outputMantissa,
                            outputExponent);
   }
   return true;
 }
 
 // Takes a pointer to a string and a pointer to a string pointer. This function
 // is used as the backend for all of the string to float functions.
 template <class T>
-static inline T strtofloatingpoint(const char *__restrict src,
-                                   char **__restrict strEnd) {
+LIBC_INLINE T strtofloatingpoint(const char *__restrict src,
   using BitsType = typename fputil::FPBits<T>::UIntType;
   fputil::FPBits<T> result = fputil::FPBits<T>();
   const char *original_src = src;
   bool seen_digit = false;
   src = first_non_whitespace(src);
 
   if (*src == '+' || *src == '-') {
     if (*src == '-') {

libc/src/__support/str_to_integer.h

 //===-- String to integer conversion 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 LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 #define LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 
 #include "src/__support/CPP/limits.h"
+#include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_num_result.h"
 #include <errno.h>
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
 // character (as determined by isspace())
-static inline const char *first_non_whitespace(const char *__restrict src) {
+LIBC_INLINE const char *first_non_whitespace(const char *__restrict src) {
   while (internal::isspace(*src)) {
     ++src;
   }
   return src;
 }
 
-static inline int b36_char_to_int(char input) {
+LIBC_INLINE int b36_char_to_int(char input) {
   if (isdigit(input))
     return input - '0';
   if (isalpha(input))
     return (input | 32) + 10 - 'a';
   return 0;
 }
 
 // checks if the next 3 characters of the string pointer are the start of a
 // hexadecimal number. Does not advance the string pointer.
-static inline bool is_hex_start(const char *__restrict src) {
+LIBC_INLINE bool is_hex_start(const char *__restrict src) {
   return *src == '0' && (*(src + 1) | 32) == 'x' && isalnum(*(src + 2)) &&
          b36_char_to_int(*(src + 2)) < 16;
 }
 
 // Takes the address of the string pointer and parses the base from the start of
 // it. This function will advance |src| to the first valid digit in the inferred
 // base.
-static inline int infer_base(const char *__restrict *__restrict src) {
+LIBC_INLINE int infer_base(const char *__restrict *__restrict src) {
   // A hexadecimal number is defined as "the prefix 0x or 0X followed by a
   // sequence of the deimal digits and the letters a (or A) through f (or F)
   // with values 10 through 15 respectively." (C standard 6.4.4.1)
   if (is_hex_start(*src)) {
     (*src) += 2;
     return 16;
   } // An octal number is defined as "the prefix 0 optionally followed by a
     // sequence of the digits 0 through 7 only" (C standard 6.4.4.1) and so any
     // number that starts with 0, including just 0, is an octal number.
   else if (**src == '0') {
     return 8;
   } // A decimal number is defined as beginning "with a nonzero digit and
     // consist[ing] of a sequence of decimal digits." (C standard 6.4.4.1)
   else {
     return 10;
   }
 }
 
 // Takes a pointer to a string and the base to convert to. This function is used
 // as the backend for all of the string to int functions.
 template <class T>
-static inline StrToNumResult<T> strtointeger(const char *__restrict src,
-                                             int base) {
+LIBC_INLINE StrToNumResult<T> strtointeger(const char *__restrict src,
   unsigned long long result = 0;
   bool is_number = false;
   const char *original_src = src;
   int error_val = 0;
 
   if (base < 0 || base == 1 || base > 36) {
     error_val = EINVAL;
     return {0, 0, error_val};

libc/src/__support/threads/linux/CMakeLists.txt

add_object_library(
   thread
   SRCS
     thread.cpp
   DEPENDS
     .futex_word_type
     libc.config.linux.app_h
     libc.include.sys_syscall
     libc.src.__support.CPP.atomic
-    libc.src.__support.error_or
     libc.src.__support.CPP.stringstream
     libc.src.__support.CPP.string_view
+    libc.src.__support.common
+    libc.src.__support.error_or
     libc.src.__support.threads.thread_common
   COMPILE_OPTIONS
     -O3
     -fno-omit-frame-pointer # This allows us to sniff out the thread args from
                             # the new thread's stack reliably.
 )

libc/src/__support/threads/linux/thread.cpp

 //===--- Implementation of a Linux thread class -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/threads/thread.h"
 #include "config/linux/app.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
+#include "src/__support/common.h"
 #include "src/__support/error_or.h"
 #include "src/__support/threads/linux/futex_word.h" // For FutexWordType
 
 #ifdef LLVM_LIBC_ARCH_AARCH64
 #include <arm_acle.h>
 #endif
 
 #include <errno.h>
static constexpr unsigned CLONE_SYSCALL_FLAGS =
     | CLONE_THREAD  // Same thread group as the parent.
     | CLONE_SYSVSEM // Share a single list of System V semaphore adjustment
                     // values
     | CLONE_PARENT_SETTID  // Set child thread ID in |ptid| of the parent.
     | CLONE_CHILD_CLEARTID // Let the kernel clear the tid address
                            // wake the joining thread.
     | CLONE_SETTLS;        // Setup the thread pointer of the new thread.
 
-static inline ErrorOr<void *> alloc_stack(size_t size) {
+LIBC_INLINE ErrorOr<void *> alloc_stack(size_t size) {
   long mmap_result =
       __llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,
                                 0, // No special address
                                 size,
                                 PROT_READ | PROT_WRITE, // Read and write stack
                                 MAP_ANONYMOUS | MAP_PRIVATE, // Process private
                                 -1, // Not backed by any file
                                 0   // No offset
       );
   if (mmap_result < 0 && (uintptr_t(mmap_result) >= UINTPTR_MAX - size))
     return Error{int(-mmap_result)};
   return reinterpret_cast<void *>(mmap_result);
 }
 
-static inline void free_stack(void *stack, size_t size) {
+LIBC_INLINE void free_stack(void *stack, size_t size) {
   __llvm_libc::syscall_impl(SYS_munmap, stack, size);
 }
 
 struct Thread;
 
 // We align the start args to 16-byte boundary as we adjust the allocated
 // stack memory with its size. We want the adjusted address to be at a
 // 16-byte boundary to satisfy the x86_64 and aarch64 ABI requirements.

libc/src/string/memory_utils/bcmp_implementations.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 <stddef.h> // size_t
 
 namespace __llvm_libc {
 
-[[maybe_unused]] static inline BcmpReturnType
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_embedded_tiny(CPtr p1, CPtr p2, size_t count) {
   LLVM_LIBC_LOOP_NOUNROLL
   for (size_t offset = 0; offset < count; ++offset)
     if (auto value = generic::Bcmp<1>::block(p1 + offset, p2 + offset))
       return value;
   return BcmpReturnType::ZERO();
 }
 
 #if defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
-[[maybe_unused]] static inline BcmpReturnType
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_generic_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count < 256)
     return generic::Bcmp<16>::loop_and_tail(p1, p2, count);
   if (auto value = generic::Bcmp<64>::block(p1, p2))
     return value;
   align_to_next_boundary<64, Arg::P1>(p1, p2, count);
   return generic::Bcmp<64>::loop_and_tail(p1, p2, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
 
 #if defined(LLVM_LIBC_ARCH_X86)
-[[maybe_unused]] static inline BcmpReturnType
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_x86_sse2_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count <= 32)
     return x86::sse2::Bcmp<16>::head_tail(p1, p2, count);
   if (count < 256)
     return x86::sse2::Bcmp<16>::loop_and_tail(p1, p2, count);
   if (auto value = x86::sse2::Bcmp<16>::block(p1, p2))
     return value;
   align_to_next_boundary<16, Arg::P1>(p1, p2, count);
   return x86::sse2::Bcmp<64>::loop_and_tail(p1, p2, count);
 }
 
-[[maybe_unused]] static inline BcmpReturnType
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_x86_avx2_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count <= 32)
     return x86::sse2::Bcmp<16>::head_tail(p1, p2, count);
   if (count <= 64)
     return x86::avx2::Bcmp<32>::head_tail(p1, p2, count);
   if (count <= 128)
     return x86::avx2::Bcmp<64>::head_tail(p1, p2, count);
   if (unlikely(count >= 256)) {
     if (auto value = x86::avx2::Bcmp<64>::block(p1, p2))
       return value;
     align_to_next_boundary<64, Arg::P1>(p1, p2, count);
   }
   return x86::avx2::Bcmp<64>::loop_and_tail(p1, p2, count);
 }
 
-[[maybe_unused]] static inline BcmpReturnType
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_x86_avx512bw_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count <= 32)
     return x86::sse2::Bcmp<16>::head_tail(p1, p2, count);
   if (count <= 64)
     return x86::avx2::Bcmp<32>::head_tail(p1, p2, count);
   if (count <= 128)
     return x86::avx512bw::Bcmp<64>::head_tail(p1, p2, count);
   if (unlikely(count >= 256)) {
     if (auto value = x86::avx512bw::Bcmp<64>::block(p1, p2))
       return value;
     align_to_next_boundary<64, Arg::P1>(p1, p2, count);
   }
   return x86::avx512bw::Bcmp<64>::loop_and_tail(p1, p2, count);
 }
 
-[[maybe_unused]] static inline BcmpReturnType inline_bcmp_x86(CPtr p1, CPtr p2,
-                                                              size_t count) {
+[[maybe_unused]] LIBC_INLINE BcmpReturnType inline_bcmp_x86(CPtr p1, CPtr p2,
   if (count == 0)
     return BcmpReturnType::ZERO();
   if (count == 1)
     return generic::Bcmp<1>::block(p1, p2);
   if (count == 2)
     return generic::Bcmp<2>::block(p1, p2);
   if (count <= 4)
     return generic::Bcmp<2>::head_tail(p1, p2, count);
   if (count <= 8)
     return generic::Bcmp<4>::head_tail(p1, p2, count);
   if (count <= 16)
     return generic::Bcmp<8>::head_tail(p1, p2, count);
   if constexpr (x86::kAvx512BW)
     return inline_bcmp_x86_avx512bw_gt16(p1, p2, count);
   else if constexpr (x86::kAvx2)
     return inline_bcmp_x86_avx2_gt16(p1, p2, count);
   else if constexpr (x86::kSse2)
     return inline_bcmp_x86_sse2_gt16(p1, p2, count);
   else
     return inline_bcmp_generic_gt16(p1, p2, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_X86)
 
 #if defined(LLVM_LIBC_ARCH_AARCH64)
-[[maybe_unused]] static inline BcmpReturnType
-inline_bcmp_aarch64(CPtr p1, CPtr p2, size_t count) {
+[[maybe_unused]] LIBC_INLINE BcmpReturnType inline_bcmp_aarch64(CPtr p1,
+                                                                CPtr p2,
+                                                                size_t count) {
   if (likely(count <= 32)) {
     if (unlikely(count >= 16)) {
       return aarch64::Bcmp<16>::head_tail(p1, p2, count);
     }
     switch (count) {
     case 0:
       return BcmpReturnType::ZERO();
     case 1:
if (unlikely(count > 256)) {
     if (auto value = aarch64::Bcmp<32>::block(p1, p2))
       return value;
     align_to_next_boundary<16, Arg::P1>(p1, p2, count);
   }
   return aarch64::Bcmp<32>::loop_and_tail(p1, p2, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
-static inline BcmpReturnType inline_bcmp(CPtr p1, CPtr p2, size_t count) {
+LIBC_INLINE BcmpReturnType inline_bcmp(CPtr p1, CPtr p2, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86)
   return inline_bcmp_x86(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   return inline_bcmp_aarch64(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_bcmp_embedded_tiny(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_GPU)
   return inline_bcmp_embedded_tiny(p1, p2, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
-static inline int inline_bcmp(const void *p1, const void *p2, size_t count) {
+LIBC_INLINE int inline_bcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_bcmp(reinterpret_cast<CPtr>(p1),
                                       reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcmp_implementations.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]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_embedded_tiny(CPtr p1, CPtr p2, size_t count) {
   LLVM_LIBC_LOOP_NOUNROLL
   for (size_t offset = 0; offset < count; ++offset)
     if (auto value = generic::Memcmp<1>::block(p1 + offset, p2 + offset))
       return value;
   return MemcmpReturnType::ZERO();
 }
 
 #if defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
-[[maybe_unused]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_generic_gt16(CPtr p1, CPtr p2, size_t count) {
   if (unlikely(count >= 384)) {
     if (auto value = generic::Memcmp<16>::block(p1, p2))
       return value;
     align_to_next_boundary<16, Arg::P1>(p1, p2, count);
   }
   return generic::Memcmp<16>::loop_and_tail(p1, p2, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
 
 #if defined(LLVM_LIBC_ARCH_X86)
-[[maybe_unused]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_x86_sse2_gt16(CPtr p1, CPtr p2, size_t count) {
   if (unlikely(count >= 384)) {
     if (auto value = x86::sse2::Memcmp<16>::block(p1, p2))
       return value;
     align_to_next_boundary<16, Arg::P1>(p1, p2, count);
   }
   return x86::sse2::Memcmp<16>::loop_and_tail(p1, p2, count);
 }
 
-[[maybe_unused]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_x86_avx2_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count <= 32)
     return x86::sse2::Memcmp<16>::head_tail(p1, p2, count);
   if (count <= 64)
     return x86::avx2::Memcmp<32>::head_tail(p1, p2, count);
   if (count <= 128)
     return x86::avx2::Memcmp<64>::head_tail(p1, p2, count);
   if (unlikely(count >= 384)) {
     if (auto value = x86::avx2::Memcmp<32>::block(p1, p2))
       return value;
     align_to_next_boundary<32, Arg::P1>(p1, p2, count);
   }
   return x86::avx2::Memcmp<32>::loop_and_tail(p1, p2, count);
 }
 
-[[maybe_unused]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_x86_avx512bw_gt16(CPtr p1, CPtr p2, size_t count) {
   if (count <= 32)
     return x86::sse2::Memcmp<16>::head_tail(p1, p2, count);
   if (count <= 64)
     return x86::avx2::Memcmp<32>::head_tail(p1, p2, count);
   if (count <= 128)
     return x86::avx512bw::Memcmp<64>::head_tail(p1, p2, count);
   if (unlikely(count >= 384)) {
     if (auto value = x86::avx512bw::Memcmp<64>::block(p1, p2))
       return value;
     align_to_next_boundary<64, Arg::P1>(p1, p2, count);
   }
   return x86::avx512bw::Memcmp<64>::loop_and_tail(p1, p2, count);
 }
 
 #endif // defined(LLVM_LIBC_ARCH_X86)
 
 #if defined(LLVM_LIBC_ARCH_AARCH64)
-[[maybe_unused]] static inline MemcmpReturnType
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_aarch64_neon_gt16(CPtr p1, CPtr p2, size_t count) {
   if (unlikely(count >= 128)) { // [128, ∞]
     if (auto value = generic::Memcmp<16>::block(p1, p2))
       return value;
     align_to_next_boundary<16, Arg::P1>(p1, p2, count);
     return generic::Memcmp<32>::loop_and_tail(p1, p2, count);
   }
   if (generic::Bcmp<16>::block(p1, p2)) // [16, 16]
     return generic::Memcmp<16>::block(p1, p2);
   if (count < 32) // [17, 31]
     return generic::Memcmp<16>::tail(p1, p2, count);
   if (generic::Bcmp<16>::block(p1 + 16, p2 + 16)) // [32, 32]
     return generic::Memcmp<16>::block(p1 + 16, p2 + 16);
   if (count < 64) // [33, 63]
     return generic::Memcmp<32>::tail(p1, p2, count);
   // [64, 127]
   return generic::Memcmp<16>::loop_and_tail(p1 + 32, p2 + 32, count - 32);
 }
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
-static inline MemcmpReturnType inline_memcmp(CPtr p1, CPtr p2, size_t count) {
+LIBC_INLINE MemcmpReturnType inline_memcmp(CPtr p1, CPtr p2, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
   if (count == 0)
     return MemcmpReturnType::ZERO();
   if (count == 1)
     return generic::Memcmp<1>::block(p1, p2);
   if (count == 2)
     return generic::Memcmp<2>::block(p1, p2);
   if (count == 3)
#elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memcmp_embedded_tiny(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_GPU)
   return inline_memcmp_embedded_tiny(p1, p2, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
-static inline int inline_memcmp(const void *p1, const void *p2, size_t count) {
+LIBC_INLINE int inline_memcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_memcmp(reinterpret_cast<CPtr>(p1),
                                         reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcpy_implementations.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]] static inline void
+[[maybe_unused]] LIBC_INLINE void
 inline_memcpy_embedded_tiny(Ptr __restrict dst, CPtr __restrict src,
                             size_t count) {
   LLVM_LIBC_LOOP_NOUNROLL
   for (size_t offset = 0; offset < count; ++offset)
     builtin::Memcpy<1>::block(dst + offset, src + offset);
 }
 
 #if defined(LLVM_LIBC_ARCH_X86)
-[[maybe_unused]] static inline void
+[[maybe_unused]] LIBC_INLINE void
 inline_memcpy_x86(Ptr __restrict dst, CPtr __restrict src, size_t count) {
   if (count == 0)
     return;
   if (count == 1)
     return builtin::Memcpy<1>::block(dst, src);
   if (count == 2)
     return builtin::Memcpy<2>::block(dst, src);
   if (count == 3)
inline_memcpy_x86(Ptr __restrict dst, CPtr __restrict src, size_t count) {
   if (x86::kAvx && count < 256)
     return builtin::Memcpy<128>::head_tail(dst, src, count);
   builtin::Memcpy<32>::block(dst, src);
   align_to_next_boundary<32, Arg::Dst>(dst, src, count);
   static constexpr size_t kBlockSize = x86::kAvx ? 64 : 32;
   return builtin::Memcpy<kBlockSize>::loop_and_tail(dst, src, count);
 }
 
-[[maybe_unused]] static inline void
+[[maybe_unused]] LIBC_INLINE void
 inline_memcpy_x86_maybe_interpose_repmovsb(Ptr __restrict dst,
                                            CPtr __restrict src, size_t count) {
   // Whether to use rep;movsb exclusively, not at all, or only above a certain
   // threshold.
 #ifndef LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE
 #define LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE -1
 #endif
 
if (unlikely(count >= kRepMovsbThreshold))
       return x86::Memcpy::repmovsb(dst, src, count);
     else
       return inline_memcpy_x86(dst, src, count);
   }
 }
 #endif // defined(LLVM_LIBC_ARCH_X86)
 
 #if defined(LLVM_LIBC_ARCH_AARCH64)
-[[maybe_unused]] static inline void
+[[maybe_unused]] LIBC_INLINE void
 inline_memcpy_aarch64(Ptr __restrict dst, CPtr __restrict src, size_t count) {
   if (count == 0)
     return;
   if (count == 1)
     return builtin::Memcpy<1>::block(dst, src);
   if (count == 2)
     return builtin::Memcpy<2>::block(dst, src);
   if (count == 3)
inline_memcpy_aarch64(Ptr __restrict dst, CPtr __restrict src, size_t count) {
   if (count < 128)
     return builtin::Memcpy<64>::head_tail(dst, src, count);
   builtin::Memcpy<16>::block(dst, src);
   align_to_next_boundary<16, Arg::Src>(dst, src, count);
   return builtin::Memcpy<64>::loop_and_tail(dst, src, count);
 }
 #endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
-static inline void inline_memcpy(Ptr __restrict dst, CPtr __restrict src,
-                                 size_t count) {
+LIBC_INLINE void inline_memcpy(Ptr __restrict dst, CPtr __restrict src,
   using namespace __llvm_libc::builtin;
 #if defined(LLVM_LIBC_ARCH_X86)
   return inline_memcpy_x86_maybe_interpose_repmovsb(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   return inline_memcpy_aarch64(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memcpy_embedded_tiny(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_GPU)
   return inline_memcpy_embedded_tiny(dst, src, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
-static inline void inline_memcpy(void *__restrict dst,
-                                 const void *__restrict src, size_t count) {
+LIBC_INLINE void inline_memcpy(void *__restrict dst, const void *__restrict src,
+                               size_t count) {
   inline_memcpy(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.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 <stddef.h> // size_t, ptrdiff_t
 
 namespace __llvm_libc {
 
-[[maybe_unused]] static inline void
+[[maybe_unused]] LIBC_INLINE void
 inline_memmove_embedded_tiny(Ptr dst, CPtr src, size_t count) {
   if ((count == 0) || (dst == src))
     return;
   if (dst < src) {
     LLVM_LIBC_LOOP_NOUNROLL
     for (size_t offset = 0; offset < count; ++offset)
       builtin::Memcpy<1>::block(dst + offset, src + offset);
   } else {
     LLVM_LIBC_LOOP_NOUNROLL
     for (ptrdiff_t offset = count - 1; offset >= 0; --offset)
       builtin::Memcpy<1>::block(dst + offset, src + offset);
   }
 }
 
 template <size_t MaxSize>
-[[maybe_unused]] static inline void inline_memmove_generic(Ptr dst, CPtr src,
-                                                           size_t count) {
+[[maybe_unused]] LIBC_INLINE void inline_memmove_generic(Ptr dst, CPtr src,
   if (count == 0)
     return;
   if (count == 1)
     return generic::Memmove<1, MaxSize>::block(dst, src);
   if (count <= 4)
     return generic::Memmove<2, MaxSize>::head_tail(dst, src, count);
   if (count <= 8)
     return generic::Memmove<4, MaxSize>::head_tail(dst, src, count);
[[maybe_unused]] LIBC_INLINE void inline_memmove_generic(Ptr dst, CPtr src,
   } else {
     generic::Memmove<32, MaxSize>::template align_backward<Arg::Src>(dst, src,
                                                                      count);
     return generic::Memmove<64, MaxSize>::loop_and_tail_backward(dst, src,
                                                                  count);
   }
 }
 
-static inline void inline_memmove(Ptr dst, CPtr src, size_t count) {
+LIBC_INLINE void inline_memmove(Ptr dst, CPtr src, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)
 #if defined(LLVM_LIBC_ARCH_X86)
   static constexpr size_t kMaxSize = x86::kAvx512F ? 64
                                      : x86::kAvx   ? 32
                                      : x86::kSse2  ? 16
                                                    : 8;
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   static constexpr size_t kMaxSize = aarch64::kNeon ? 16 : 8;
#elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memmove_embedded_tiny(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_GPU)
   return inline_memmove_embedded_tiny(dst, src, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
-static inline void inline_memmove(void *dst, const void *src, size_t count) {
+LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
   inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src),
                  count);
 }
 
 } // namespace __llvm_libc
 
 #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/op_aarch64.h

 
 static inline constexpr bool kNeon = LLVM_LIBC_IS_DEFINED(__ARM_NEON);
 
 namespace neon {
 
 template <size_t Size> struct BzeroCacheLine {
   static constexpr size_t SIZE = Size;
 
-  static inline void block(Ptr dst, uint8_t) {
+  LIBC_INLINE void block(Ptr dst, uint8_t) {
     static_assert(Size == 64);
 #if __SIZEOF_POINTER__ == 4
     asm("dc zva, %w[dst]" : : [dst] "r"(dst) : "memory");
 #else
     asm("dc zva, %[dst]" : : [dst] "r"(dst) : "memory");
 #endif
   }
 
-  static inline void loop_and_tail(Ptr dst, uint8_t value, size_t count) {
+  LIBC_INLINE 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);
     // Unaligned store, we can't use 'dc zva' here.
     static constexpr size_t kMaxSize = kNeon ? 16 : 8;

 } // namespace neon
 
 ///////////////////////////////////////////////////////////////////////////////
 // Bcmp
 template <size_t Size> struct Bcmp {
   static constexpr size_t SIZE = Size;
   static constexpr size_t BlockSize = 32;
 
-  static const unsigned char *as_u8(CPtr ptr) {
+  LIBC_INLINE static const unsigned char *as_u8(CPtr ptr) {
     return reinterpret_cast<const unsigned char *>(ptr);
   }
 
-  static inline BcmpReturnType block(CPtr p1, CPtr p2) {
+  LIBC_INLINE static BcmpReturnType block(CPtr p1, CPtr p2) {
     if constexpr (Size == 16) {
       auto _p1 = as_u8(p1);
       auto _p2 = as_u8(p2);
       uint8x16_t a = vld1q_u8(_p1);
       uint8x16_t n = vld1q_u8(_p2);
       uint8x16_t an = veorq_u8(a, n);
       uint32x2_t an_reduced = vqmovn_u64(vreinterpretq_u64_u8(an));
       return vmaxv_u32(an_reduced);
if constexpr (Size == 16) {
         if (auto value = Bcmp<BlockSize>::block(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) {
     if constexpr (Size == 16) {
       auto _p1 = as_u8(p1);
       auto _p2 = as_u8(p2);
       uint8x16_t a = vld1q_u8(_p1);
       uint8x16_t b = vld1q_u8(_p1 + count - 16);
       uint8x16_t n = vld1q_u8(_p2);
       uint8x16_t o = vld1q_u8(_p2 + count - 16);
       uint8x16_t an = veorq_u8(a, n);
if constexpr (Size == 16) {
       uint32x2_t abnocpdq_reduced = vqmovn_u64(abnocpdq);
       return vmaxv_u32(abnocpdq_reduced);
     } else {
       deferred_static_assert("SIZE not implemented");
     }
     return BcmpReturnType::ZERO();
   }
 
-  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 __llvm_libc::aarch64
 
 #endif // LLVM_LIBC_ARCH_AARCH64
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_OP_AARCH64_H