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

[michaelrj]

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

26

do we want to keep the always_inline attribute?

[sivachandra]

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

26

I don't think we need it. At sufficient optimization levels, just the inline tag is sufficient.

[michaelrj]

LGTM

libc/src/__support/CMakeLists.txt

 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
+    libc.src.__support.common
 )
 
 
 add_header_library(
   float_to_string
   HDRS
     float_to_string.h
     ryu_constants.h
add_header_library(
   HDRS
     integer_operations.h
 )
 
 add_header_library(
   arg_list
   HDRS
     arg_list.h
+  DEPENDS
+    libc.src.__support.common
 )
 
 add_header_library(
   fixedvector
   HDRS
     fixedvector.h
   DEPENDS
     libc.src.__support.CPP.array
 )
 
 add_header_library(
   char_vector
   HDRS
     char_vector.h
+  DEPENDS
+    libc.src.__support.common
 )
 
 add_header_library(
   number_pair
   HDRS
     number_pair.h
   DEPENDS
     .named_pair
     libc.src.__support.CPP.type_traits
 )
 
 add_header_library(
   integer_utils
   HDRS
     integer_utils.h
   DEPENDS
     .builtin_wrappers
     .number_pair
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
 )
 
 add_header_library(
   uint
   HDRS
     UInt.h
   DEPENDS
     .builtin_wrappers

libc/src/__support/FPUtil/CMakeLists.txt

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

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

 //===-- Square root of IEEE 754 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_AARCH64_SQRT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_SQRT_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_AARCH64)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/generic/sqrt.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <> inline float sqrt<float>(float x) {
+template <> LIBC_INLINE float sqrt<float>(float x) {
   float y;
   __asm__ __volatile__("fsqrt %s0, %s1\n\t" : "=w"(y) : "w"(x));
   return y;
 }
 
-template <> inline double sqrt<double>(double x) {
+template <> LIBC_INLINE double sqrt<double>(double x) {
   double y;
   __asm__ __volatile__("fsqrt %d0, %d1\n\t" : "=w"(y) : "w"(x));
   return y;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_SQRT_H

libc/src/__support/FPUtil/generic/CMakeLists.txt

 add_header_library(
   sqrt
   HDRS
     sqrt.h
     sqrt_80_bit_long_double.h
   DEPENDS
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
     libc.src.__support.FPUtil.fenv_impl
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.platform_defs
     libc.src.__support.builtin_wrappers
+    libc.src.__support.common
     libc.src.__support.uint128
     libc.include.fenv
 )
 
 add_header_library(
   fma
   HDRS
     FMA.h

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

 namespace fputil {
 namespace generic {
 
 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) {
+template <> LIBC_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);
   double sum = prod + z_d;
   fputil::FPBits<double> bit_prod(prod), bitz(z_d), bit_sum(sum);
 
   if (!(bit_sum.is_inf_or_nan() || bit_sum.is_zero())) {
     // Since the sum is computed in double precision, rounding might happen
LIBC_INLINE bool shift_mantissa(int shift_length, UInt128 &mant) {
   UInt128 mask = (UInt128(1) << shift_length) - 1;
   bool sticky_bits = (mant & mask) != 0;
   mant >>= shift_length;
   return sticky_bits;
 }
 
 } // namespace internal
 
-template <> inline double fma<double>(double x, double y, double z) {
+template <> LIBC_INLINE double fma<double>(double x, double y, double z) {
   using FPBits = fputil::FPBits<double>;
   using FloatProp = fputil::FloatProperties<double>;
 
   if (unlikely(x == 0 || y == 0 || z == 0)) {
     return x * y + z;
   }
 
   int x_exp = 0;

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

 #include "sqrt_80_bit_long_double.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.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> struct SpecialLongDouble {
   static constexpr bool VALUE = false;
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 <>
-inline void normalize<long double>(int &exponent, uint64_t &mantissa) {
+LIBC_INLINE void normalize<long double>(int &exponent, uint64_t &mantissa) {
   normalize<double>(exponent, mantissa);
 }
 #elif !defined(SPECIAL_X86_LONG_DOUBLE)
 template <>
-inline void normalize<long double>(int &exponent, UInt128 &mantissa) {
+LIBC_INLINE void normalize<long double>(int &exponent, UInt128 &mantissa) {
   const uint64_t hi_bits = static_cast<uint64_t>(mantissa >> 64);
   const int shift = hi_bits
                         ? (unsafe_clz(hi_bits) - 15)
                         : (unsafe_clz(static_cast<uint64_t>(mantissa)) + 49);
   exponent -= shift;
   mantissa <<= shift;
 }
 #endif

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

 //===-- Square root of x86 long double numbers ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_80_BIT_LONG_DOUBLE_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_80_BIT_LONG_DOUBLE_H
 
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace x86 {
 
-inline void normalize(int &exponent, UInt128 &mantissa) {
+LIBC_INLINE void normalize(int &exponent, UInt128 &mantissa) {
   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

libc/src/__support/FPUtil/multiply_add.h

 #if defined(LIBC_TARGET_HAS_FMA)
 
 // FMA instructions are available.
 #include "FMA.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <> inline float multiply_add<float>(float x, float y, float z) {
+template <> LIBC_INLINE float multiply_add<float>(float x, float y, float z) {
   return fma(x, y, z);
 }
 
-template <> inline double multiply_add<double>(double x, double y, double z) {
+template <>
+LIBC_INLINE double multiply_add<double>(double x, double y, double z) {
   return fma(x, y, z);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LIBC_TARGET_HAS_FMA
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_MULTIPLY_ADD_H

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

 //===-- Optimized PolyEval implementations for 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_POLYEVAL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_POLYEVAL_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86_64)
 #error "Invalid include"
 #endif
 
 #include <immintrin.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // Cubic polynomials:
 //   polyeval(x, a0, a1, a2, a3) = a3*x^3 + a2*x^2 + a1*x + a0
 template <>
-inline float polyeval(float x, float a0, float a1, float a2, float a3) {
+LIBC_INLINE float polyeval(float x, float a0, float a1, float a2, float a3) {
   __m128 xmm = _mm_set1_ps(x);                 // NOLINT
   __m128 a13 = _mm_set_ps(0.0f, x, a3, a1);    // NOLINT
   __m128 a02 = _mm_set_ps(0.0f, 0.0f, a2, a0); // NOLINT
   // r = (0, x^2, a3*x + a2, a1*x + a0)
   __m128 r = _mm_fmadd_ps(a13, xmm, a02); // NOLINT
   // result = (a3*x + a2) * x^2 + (a1*x + a0)
   return fma(r[2], r[1], r[0]);
 }
 
 template <>
-inline double polyeval(double x, double a0, double a1, double a2, double a3) {
+LIBC_INLINE double polyeval(double x, double a0, double a1, double a2,
+                            double a3) {
   __m256d xmm = _mm256_set1_pd(x);               // NOLINT
   __m256d a13 = _mm256_set_pd(0.0, x, a3, a1);   // NOLINT
   __m256d a02 = _mm256_set_pd(0.0, 0.0, a2, a0); // NOLINT
   // r = (0, x^2, a3*x + a2, a1*x + a0)
   __m256d r = _mm256_fmadd_pd(a13, xmm, a02); // NOLINT
   // result = (a3*x + a2) * x^2 + (a1*x + a0)
   return fma(r[2], r[1], r[0]);
 }
 
 // Quintic polynomials:
 //   polyeval(x, a0, a1, a2, a3, a4, a5) = a5*x^5 + a4*x^4 + a3*x^3 + a2*x^2 +
 //                                         + a1*x + a0
 template <>
-inline float polyeval(float x, float a0, float a1, float a2, float a3, float a4,
-                      float a5) {
+LIBC_INLINE float polyeval(float x, float a0, float a1, float a2, float a3,
+                           float a4, float a5) {
   __m128 xmm = _mm_set1_ps(x);                 // NOLINT
   __m128 a25 = _mm_set_ps(0.0f, x, a5, a2);    // NOLINT
   __m128 a14 = _mm_set_ps(0.0f, 0.0f, a4, a1); // NOLINT
   __m128 a03 = _mm_set_ps(0.0f, 0.0f, a3, a0); // NOLINT
   // r1 = (0, x^2, a5*x + a4, a2*x + a1)
   __m128 r1 = _mm_fmadd_ps(a25, xmm, a14); // NOLINT
   // r2 = (0, x^3, (a5*x + a4)*x + a3, (a2*x + a1)*x + a0
   __m128 r2 = _mm_fmadd_ps(r1, xmm, a03); // NOLINT
   // result = ((a5*x + a4)*x + a3) * x^3 + ((a2*x + a1)*x + a0)
   return fma(r2[2], r2[1], r2[0]);
 }
 
 template <>
-inline double polyeval(double x, double a0, double a1, double a2, double a3,
-                       double a4, double a5) {
+LIBC_INLINE double polyeval(double x, double a0, double a1, double a2,
+                            double a3, double a4, double a5) {
   __m256d xmm = _mm256_set1_pd(x);               // NOLINT
   __m256d a25 = _mm256_set_pd(0.0, x, a5, a2);   // NOLINT
   __m256d a14 = _mm256_set_pd(0.0, 0.0, a4, a1); // NOLINT
   __m256d a03 = _mm256_set_pd(0.0, 0.0, a3, a0); // NOLINT
   // r1 = (0, x^2, a5*x + a4, a2*x + a1)
   __m256d r1 = _mm256_fmadd_pd(a25, xmm, a14); // NOLINT
   // r2 = (0, x^3, (a5*x + a4)*x + a3, (a2*x + a1)*x + a0
   __m256d r2 = _mm256_fmadd_pd(r1, xmm, a03); // NOLINT
   // result = ((a5*x + a4)*x + a3) * x^3 + ((a2*x + a1)*x + a0)
   return fma(r2[2], r2[1], r2[0]);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_POLYEVAL_H

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

 //===-- Square root of IEEE 754 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_X86_64_SQRT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/generic/sqrt.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <> inline float sqrt<float>(float x) {
+template <> LIBC_INLINE float sqrt<float>(float x) {
   float result;
   __asm__ __volatile__("sqrtss %x1, %x0" : "=x"(result) : "x"(x));
   return result;
 }
 
-template <> inline double sqrt<double>(double x) {
+template <> LIBC_INLINE double sqrt<double>(double x) {
   double result;
   __asm__ __volatile__("sqrtsd %x1, %x0" : "=x"(result) : "x"(x));
   return result;
 }
 
 #ifdef LONG_DOUBLE_IS_DOUBLE
-template <> inline long double sqrt<long double>(long double x) {
+template <> LIBC_INLINE long double sqrt<long double>(long double x) {
   long double result;
   __asm__ __volatile__("sqrtsd %x1, %x0" : "=x"(result) : "x"(x));
   return result;
 }
 #else
-template <> inline long double sqrt<long double>(long double x) {
+template <> LIBC_INLINE long double sqrt<long double>(long double x) {
   __asm__ __volatile__("fsqrt" : "+t"(x));
   return x;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_H

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

 //===----------------------- Linux syscalls ---------------------*- 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_SYSCALL_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_SYSCALL_H
 
 #include "src/__support/architectures.h"
+#include "src/__support/common.h"
 
 #ifdef LLVM_LIBC_ARCH_X86_64
 #include "x86_64/syscall.h"
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/syscall.h"
 #elif defined(LLVM_LIBC_ARCH_ARM)
 #include "arm/syscall.h"
 #endif
 
 namespace __llvm_libc {
 
 template <typename... Ts>
-__attribute__((always_inline)) inline long syscall_impl(long __number,
-                                                        Ts... ts) {
+LIBC_INLINE long syscall_impl(long __number, Ts... ts) {
   static_assert(sizeof...(Ts) <= 6, "Too many arguments for syscall");
   return syscall_impl(__number, (long)ts...);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_SYSCALL_H

libc/src/__support/arg_list.h

 //===-- Holder Class for manipulating va_lists ------------------*- 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_ARG_LIST_H
 #define LLVM_LIBC_SRC_SUPPORT_ARG_LIST_H
 
+#include "src/__support/common.h"
+
 #include <stdarg.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 class ArgList {
   va_list vlist;
 
 public:
-  ArgList(va_list vlist) { va_copy(this->vlist, vlist); }
-  ArgList(ArgList &other) { va_copy(this->vlist, other.vlist); }
-  ~ArgList() { va_end(this->vlist); }
+  LIBC_INLINE ArgList(va_list vlist) { va_copy(this->vlist, vlist); }
+  LIBC_INLINE ArgList(ArgList &other) { va_copy(this->vlist, other.vlist); }
+  LIBC_INLINE ~ArgList() { va_end(this->vlist); }
 
-  ArgList &operator=(ArgList &rhs) {
+  LIBC_INLINE ArgList &operator=(ArgList &rhs) {
     va_copy(vlist, rhs.vlist);
     return *this;
   }
 
-  template <class T> T inline next_var() { return va_arg(vlist, T); }
+  template <class T> LIBC_INLINE T next_var() { return va_arg(vlist, T); }
 };
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ARG_LIST_H

libc/src/__support/char_vector.h

 //===-- Standalone implementation of a char vector --------------*- 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_CHARVECTOR_H
 #define LLVM_LIBC_SRC_SUPPORT_CHARVECTOR_H
 
+#include "src/__support/common.h"
+
 #include <stddef.h>
 #include <stdlib.h> // For allocation.
 
 namespace __llvm_libc {
 
 // This is very simple alternate of the std::string class. There is no
 // bounds check performed in any of the methods. The callers are expected to
 // do the checks before invoking the methods.
 //
 // This class will be extended as needed in future.
 
 class CharVector {
   static constexpr size_t INIT_BUFF_SIZE = 64;
   char local_buffer[INIT_BUFF_SIZE];
   char *cur_str = local_buffer;
   size_t cur_buff_size = INIT_BUFF_SIZE;
   size_t index = 0;
 
 public:
   CharVector() = default;
-  ~CharVector() {
+  LIBC_INLINE ~CharVector() {
     if (cur_str != local_buffer)
       free(cur_str);
   }
 
   // append returns true on success and false on allocation failure.
-  bool append(char new_char) {
+  LIBC_INLINE bool append(char new_char) {
     // Subtract 1 for index starting at 0 and another for the null terminator.
     if (index >= cur_buff_size - 2) {
       // If the new character would cause the string to be longer than the
       // buffer's size, attempt to allocate a new buffer.
       cur_buff_size = cur_buff_size * 2;
       if (cur_str == local_buffer) {
         char *new_str;
         new_str = reinterpret_cast<char *>(malloc(cur_buff_size));
if (index >= cur_buff_size - 2) {
         }
       }
     }
     cur_str[index] = new_char;
     ++index;
     return true;
   }
 
-  char *c_str() {
+  LIBC_INLINE char *c_str() {
     cur_str[index] = '\0';
     return cur_str;
   }
 
-  size_t length() { return index; }
+  LIBC_INLINE size_t length() { return index; }
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CHARVECTOR_H

libc/src/__support/float_to_string.h

 constexpr size_t POW10_ADDITIONAL_BITS_CALC = 128;
 constexpr size_t POW10_ADDITIONAL_BITS_TABLE = 120;
 
 constexpr size_t MID_INT_SIZE = 192;
 
 namespace internal {
 
 // Returns floor(log_10(2^e)); requires 0 <= e <= 1650.
-constexpr inline uint32_t log10_pow2(const uint32_t e) {
+LIBC_INLINE constexpr uint32_t log10_pow2(const uint32_t e) {
   // The first value this approximation fails for is 2^1651 which is just
   // greater than 10^297. assert(e >= 0); assert(e <= 1650);
   return (e * 78913) >> 18;
 }
 
 // Returns 1 + floor(log_10(2^e). This could technically be off by 1 if any
 // power of 2 was also a power of 10, but since that doesn't exist this is
 // always accurate. This is used to calculate the maximum number of base-10
 // digits a given e-bit number could have.
-constexpr inline uint32_t ceil_log10_pow2(const uint32_t e) {
+LIBC_INLINE constexpr uint32_t ceil_log10_pow2(const uint32_t e) {
   return log10_pow2(e) + 1;
 }
 
 // Returns the maximum number of 9 digit blocks a number described by the given
 // index (which is ceil(exponent/16)) and mantissa width could need.
-constexpr inline uint32_t length_for_num(const uint32_t idx,
+LIBC_INLINE constexpr uint32_t length_for_num(const uint32_t idx,
                                               const uint32_t mantissa_width) {
   //+8 to round up when dividing by 9
   return (ceil_log10_pow2(16 * idx) + ceil_log10_pow2(mantissa_width) +
           (BLOCK_SIZE - 1)) /
          BLOCK_SIZE;
   // return (ceil_log10_pow2(16 * idx + mantissa_width) + 8) / 9;
 }
 
 // The formula for the table when i is positive (or zero) is as follows:
 // floor(10^(-9i) * 2^(e + c_1) + 1) % (10^9 * 2^c_1)
 // Rewritten slightly we get:
 // floor(5^(-9i) * 2^(e + c_1 - 9i) + 1) % (10^9 * 2^c_1)
 
 template <size_t INT_SIZE>
-constexpr inline cpp::UInt<MID_INT_SIZE>
+LIBC_INLINE constexpr cpp::UInt<MID_INT_SIZE>
 get_table_positive(int exponent, size_t i, const size_t constant) {
   // INT_SIZE is the size of int that is used for the internal calculations of
   // this function. It should be large enough to hold 2^(exponent+constant), so
   // ~1000 for double and ~16000 for long double. Be warned that the time
   // complexity of exponentiation is O(n^2 * log_2(m)) where n is the number of
   // bits in the number being exponentiated and m is the exponent.
   int shift_amount = exponent + constant - (9 * i);
   if (shift_amount < 0) {

 // The formula for the table when i is negative (or zero) is as follows:
 // floor(10^(-9i) * 2^(c_0 - e)) % (10^9 * 2^c_0)
 // Since we know i is always negative, we just take it as unsigned and treat it
 // as negative. We do the same with exponent, while they're both always negative
 // in theory, in practice they're converted to positive for simpler
 // calculations.
 // The formula being used looks more like this:
 // floor(10^(9*(-i)) * 2^(c_0 + (-e))) % (10^9 * 2^c_0)
-inline cpp::UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i,
+LIBC_INLINE cpp::UInt<MID_INT_SIZE> get_table_negative(int exponent, size_t i,
                                                        const size_t constant) {
   constexpr size_t INT_SIZE = 1024;
   int shift_amount = constant - exponent;
   cpp::UInt<INT_SIZE> num(1);
   // const cpp::UInt<INT_SIZE> MOD_SIZE =
   //     (cpp::UInt<INT_SIZE>(1) << constant) * 1000000000;
 
   constexpr uint64_t TEN_EXP_NINE = 1000000000;
   constexpr uint64_t FIVE_EXP_NINE = 1953125;
class FloatToString {
   MantissaInt mantissa;
 
   static constexpr int MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   static constexpr int EXP_BIAS = fputil::FPBits<T>::EXPONENT_BIAS;
 
   // constexpr void init_convert();
 
 public:
-  constexpr FloatToString(T init_float) : float_bits(init_float) {
+  LIBC_INLINE constexpr FloatToString(T init_float) : float_bits(init_float) {
     is_negative = float_bits.get_sign();
     exponent = float_bits.get_exponent();
     mantissa = float_bits.get_explicit_mantissa();
 
     // Handle the exponent for numbers with a 0 exponent.
     if (exponent == -EXP_BIAS) {
       if (mantissa > 0) { // Subnormals
         ++exponent;
       } else { // Zeroes
         exponent = 0;
       }
     }
 
     // Adjust for the width of the mantissa.
     exponent -= MANT_WIDTH;
 
     // init_convert();
   }
 
-  constexpr bool is_nan() { return float_bits.is_nan(); }
-  constexpr bool is_inf() { return float_bits.is_inf(); }
-  constexpr bool is_inf_or_nan() { return float_bits.is_inf_or_nan(); }
+  LIBC_INLINE constexpr bool is_nan() { return float_bits.is_nan(); }
+  LIBC_INLINE constexpr bool is_inf() { return float_bits.is_inf(); }
+  LIBC_INLINE constexpr bool is_inf_or_nan() {
+    return float_bits.is_inf_or_nan();
+  }
 
   // get_block returns an integer that represents the digits in the requested
   // block.
-  constexpr BlockInt get_positive_block(int block_index) {
+  LIBC_INLINE constexpr BlockInt get_positive_block(int block_index) {
     if (exponent >= -MANT_WIDTH) {
       // idx is ceil(exponent/16) or 0 if exponent is negative. This is used to
       // find the coarse section of the POW10_SPLIT table that will be used to
       // calculate the 9 digit window, as well as some other related values.
       const uint32_t idx =
           exponent < 0 ? 0 : static_cast<uint32_t>(exponent + 15) / 16;
 
       uint32_t temp_shift_amount =
           POW10_ADDITIONAL_BITS_TABLE + (16 * idx) - exponent;
       const uint32_t shift_amount = temp_shift_amount;
       // shift_amount = -(c0 - exponent) = c_0 + 16 * ceil(exponent/16) -
       // exponent
 
       int32_t i = block_index;
       cpp::UInt<MID_INT_SIZE> val;
       val = POW10_SPLIT[POW10_OFFSET[idx] + i];
 
       const uint32_t digits =
           internal::mul_shift_mod_1e9(mantissa, val, (int32_t)(shift_amount));
       return digits;
     } else {
       return 0;
     }
   }
-  constexpr BlockInt get_negative_block(int block_index) {
+
+  LIBC_INLINE constexpr BlockInt get_negative_block(int block_index) {
     if (exponent < 0) {
       const int32_t idx = -exponent / 16;
       uint32_t i = block_index;
       // if the requested block is zero
       if (i < MIN_BLOCK_2[idx]) {
         return 0;
       }
       const int32_t shift_amount =
if (exponent < 0) {
       uint32_t digits =
           internal::mul_shift_mod_1e9(mantissa, table_val, shift_amount);
       return digits;
     } else {
       return 0;
     }
   }
 
-  constexpr BlockInt get_block(int block_index) {
+  LIBC_INLINE constexpr BlockInt get_block(int block_index) {
     if (block_index >= 0) {
       return get_positive_block(block_index);
     } else {
       return get_negative_block(-1 - block_index);
     }
   }
 
-  constexpr size_t get_positive_blocks() {
+  LIBC_INLINE constexpr size_t get_positive_blocks() {
     if (exponent >= -MANT_WIDTH) {
       const uint32_t idx =
           exponent < 0 ? 0 : static_cast<uint32_t>(exponent + 15) / 16;
       const uint32_t len = internal::length_for_num(idx, MANT_WIDTH);
       return len;
     } else {
       return 0;
     }
   }
 
   // This takes the index of a block after the decimal point (a negative block)
   // and return if it's sure that all of the digits after it are zero.
-  constexpr bool is_lowest_block(size_t block_index) {
+  LIBC_INLINE constexpr bool is_lowest_block(size_t block_index) {
     const int32_t idx = -exponent / 16;
     const uint32_t p = POW10_OFFSET_2[idx] + block_index - MIN_BLOCK_2[idx];
     // If the remaining digits are all 0, then this is the lowest block.
     return p >= POW10_OFFSET_2[idx + 1];
   }
 
-  constexpr size_t zero_blocks_after_point() {
+  LIBC_INLINE constexpr size_t zero_blocks_after_point() {
     return MIN_BLOCK_2[-exponent / 16];
   }
 };
 
 // template <> constexpr void FloatToString<float>::init_convert() { ; }
 
 // template <> constexpr void FloatToString<double>::init_convert() { ; }
 
 // template <> constexpr void FloatToString<long double>::init_convert() {
 //   // TODO: More here.
 //   ;
 // }
 
 template <>
-constexpr size_t FloatToString<long double>::zero_blocks_after_point() {
+LIBC_INLINE constexpr size_t
+FloatToString<long double>::zero_blocks_after_point() {
   return 0;
 }
 
 template <>
-constexpr bool FloatToString<long double>::is_lowest_block(size_t) {
+LIBC_INLINE constexpr bool FloatToString<long double>::is_lowest_block(size_t) {
   return false;
 }
 
 template <>
-constexpr BlockInt
+LIBC_INLINE constexpr BlockInt
 FloatToString<long double>::get_positive_block(int block_index) {
   if (exponent >= -MANT_WIDTH) {
     const uint32_t pos_exp = (exponent < 0 ? 0 : exponent);
 
     uint32_t temp_shift_amount =
         POW10_ADDITIONAL_BITS_CALC + pos_exp - exponent;
     const uint32_t shift_amount = temp_shift_amount;
     // shift_amount = -(c0 - exponent) = c_0 + 16 * ceil(exponent/16) -
const BlockInt digits =
         internal::mul_shift_mod_1e9(mantissa, val, (int32_t)(shift_amount));
     return digits;
   } else {
     return 0;
   }
 }
 
 template <>
-constexpr BlockInt
+LIBC_INLINE constexpr BlockInt
 FloatToString<long double>::get_negative_block(int block_index) {
   if (exponent < 0) {
     const int32_t idx = -exponent / 16;
     uint32_t i = -1 - block_index;
     // if the requested block is zero
     if (i <= MIN_BLOCK_2[idx]) {
       return 0;
     }

libc/src/__support/integer_to_string.h

 #define LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 
 #include <stdint.h>
 
 #include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // Convert integer values to their string representation.
 //
 // Example usage:
 //   int a = 1234567;
 //

 //   // Convert to binary string:
 //   char binbuf[IntegerToString::bin_bufsize<int>(a)];
 //   auto str = IntegerToString::bin(a, binbuf);
 //
 //   // Convert to base 30 string:
 //   char b30buf[IntegerToString::bufsize<30, int>(a)];
 //   auto str = IntegerToString::convert<30>(a, b30buf);
 class IntegerToString {
-  static cpp::string_view convert_uintmax(uintmax_t uval,
+  LIBC_INLINE static cpp::string_view convert_uintmax(uintmax_t uval,
                                                       cpp::span<char> &buffer,
                                                       bool lowercase,
                                                       const uint8_t conv_base) {
     const char a = lowercase ? 'a' : 'A';
 
     size_t len = 0;
 
     size_t buffptr = buffer.size();
     if (uval == 0) {
       buffer[buffptr - 1] = '0';
       --buffptr;
     } else {
       for (; uval > 0; --buffptr, uval /= conv_base) {
         uintmax_t digit = (uval % conv_base);
         buffer[buffptr - 1] = static_cast<char>(digit < 10 ? digit + '0' : digit + a - 10);
       }
     }
     len = buffer.size() - buffptr;
 
     return cpp::string_view(buffer.data() + buffer.size() - len, len);
   }
 
-  static cpp::string_view convert_intmax(intmax_t val, cpp::span<char> &buffer,
+  LIBC_INLINE static cpp::string_view convert_intmax(intmax_t val,
+                                                     cpp::span<char> &buffer,
                                                      bool lowercase,
                                                      const uint8_t conv_base) {
     if (val >= 0)
       return convert_uintmax(uintmax_t(val), buffer, lowercase, conv_base);
     uintmax_t uval = uintmax_t(-val);
     auto str_view = convert_uintmax(uval, buffer, lowercase, conv_base);
     size_t len = str_view.size();
     ++len;
     buffer[buffer.size() - len] = '-';
     return cpp::string_view(buffer.data() + buffer.size() - len, len);
   }
 
-  static constexpr inline size_t floor_log_2(size_t num) {
+  LIBC_INLINE static constexpr size_t floor_log_2(size_t num) {
     size_t i = 0;
     for (; num > 1; num /= 2) {
       ++i;
     }
     return i;
   }
 
 public:
public:
   //
   // This estimation grows slightly faster than the actual value, but the
   // overhead is small enough to tolerate. In the actual formula below, we
   // add an additional byte to accommodate the '-' sign in case of signed
   // integers.
   // For other bases, we approximate by rounding down to the nearest power of
   // two base, since the space needed is easy to calculate and it won't
   // overestimate by too much.
-  template <uint8_t BASE, typename T> static constexpr size_t bufsize() {
+  template <uint8_t BASE, typename T>
+  LIBC_INLINE static constexpr size_t bufsize() {
     constexpr size_t BITS_PER_DIGIT = floor_log_2(BASE);
     constexpr size_t BUFSIZE_COMMON =
         ((sizeof(T) * 8 + (BITS_PER_DIGIT - 1)) / BITS_PER_DIGIT);
     constexpr size_t BUFSIZE_BASE10 = (sizeof(T) * 5 + 1) / 2;
     return (cpp::is_signed<T>() ? 1 : 0) +
            (BASE == 10 ? BUFSIZE_BASE10 : BUFSIZE_COMMON);
   }
 
-  template <typename T> static constexpr size_t dec_bufsize() {
+  template <typename T> LIBC_INLINE static constexpr size_t dec_bufsize() {
     return bufsize<10, T>();
   }
 
-  template <typename T> static constexpr size_t hex_bufsize() {
+  template <typename T> LIBC_INLINE static constexpr size_t hex_bufsize() {
     return bufsize<16, T>();
   }
 
-  template <typename T> static constexpr size_t oct_bufsize() {
+  template <typename T> LIBC_INLINE static constexpr size_t oct_bufsize() {
     return bufsize<8, T>();
   }
 
-  template <typename T> static constexpr size_t bin_bufsize() {
+  template <typename T> LIBC_INLINE static constexpr size_t bin_bufsize() {
     return bufsize<2, T>();
   }
 
   template <uint8_t BASE, typename T,
             cpp::enable_if_t<2 <= BASE && BASE <= 36 && cpp::is_integral_v<T>,
                              int> = 0>
-  static cpp::optional<cpp::string_view> convert(T val, cpp::span<char> buffer,
-                                                 bool lowercase = true) {
+  LIBC_INLINE static cpp::optional<cpp::string_view>
+  convert(T val, cpp::span<char> buffer, bool lowercase = true) {
     if (buffer.size() < bufsize<BASE, T>())
       return cpp::optional<cpp::string_view>();
     if (cpp::is_signed_v<T>)
       return convert_intmax(intmax_t(val), buffer, lowercase, BASE);
     else
       return convert_uintmax(uintmax_t(val), buffer, lowercase, BASE);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
-  static cpp::optional<cpp::string_view> dec(T val, cpp::span<char> buffer) {
+  LIBC_INLINE static cpp::optional<cpp::string_view>
+  dec(T val, cpp::span<char> buffer) {
     return convert<10>(val, buffer);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
-  static cpp::optional<cpp::string_view> hex(T val, cpp::span<char> buffer,
-                                             bool lowercase = true) {
+  LIBC_INLINE static cpp::optional<cpp::string_view>
+  hex(T val, cpp::span<char> buffer, bool lowercase = true) {
     return convert<16>(val, buffer, lowercase);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
-  static cpp::optional<cpp::string_view> oct(T val, cpp::span<char> buffer) {
+  LIBC_INLINE static cpp::optional<cpp::string_view>
+  oct(T val, cpp::span<char> buffer) {
     return convert<8>(val, buffer);
   }
 
   template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
-  static cpp::optional<cpp::string_view> bin(T val, cpp::span<char> buffer) {
+  LIBC_INLINE static cpp::optional<cpp::string_view>
+  bin(T val, cpp::span<char> buffer) {
     return convert<2>(val, buffer);
   }
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H

libc/src/__support/integer_utils.h

 //===-- Utilities for integers. ---------------------------------*- 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_INTEGER_UTILS_H
 #define LLVM_LIBC_SRC_SUPPORT_INTEGER_UTILS_H
 
-#include "CPP/type_traits.h"
+#include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
+
 #include "builtin_wrappers.h"
 #include "number_pair.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 template <typename T> NumberPair<T> full_mul(T a, T b);
 
 template <>
-inline NumberPair<uint32_t> full_mul<uint32_t>(uint32_t a, uint32_t b) {
+LIBC_INLINE NumberPair<uint32_t> full_mul<uint32_t>(uint32_t a, uint32_t b) {
   uint64_t prod = uint64_t(a) * uint64_t(b);
   NumberPair<uint32_t> result;
   result.lo = uint32_t(prod);
   result.hi = uint32_t(prod >> 32);
   return result;
 }
 
 template <>
-inline NumberPair<uint64_t> full_mul<uint64_t>(uint64_t a, uint64_t b) {
+LIBC_INLINE NumberPair<uint64_t> full_mul<uint64_t>(uint64_t a, uint64_t b) {
 #ifdef __SIZEOF_INT128__
   __uint128_t prod = __uint128_t(a) * __uint128_t(b);
   NumberPair<uint64_t> result;
   result.lo = uint64_t(prod);
   result.hi = uint64_t(prod >> 64);
   return result;
 #else
   NumberPair<uint64_t> pa = split(a);

libc/src/__support/str_to_float.h

 }
 
 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) {
+LIBC_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
eisel_lemire(typename fputil::FPBits<T>::UIntType mantissa, int32_t exp10,
 
   *outputMantissa = final_mantissa;
   *outputExp2 = exp2;
   return true;
 }
 
 #if !defined(LONG_DOUBLE_IS_DOUBLE)
 template <>
-inline bool eisel_lemire<long double>(
+LIBC_INLINE bool eisel_lemire<long double>(
     typename fputil::FPBits<long double>::UIntType mantissa, int32_t exp10,
     typename fputil::FPBits<long double>::UIntType *outputMantissa,
     uint32_t *outputExp2) {
   using BitsType = typename fputil::FPBits<long double>::UIntType;
   constexpr uint32_t BITS_IN_MANTISSA = sizeof(mantissa) * 8;
 
   // Exp10 Range
   // This doesn't reach very far into the range for long doubles, since it's

libc/src/stdio/printf_core/CMakeLists.txt

add_object_library(
   DEPENDS
     .core_structs
     libc.src.__support.arg_list
     libc.src.__support.ctype_utils
     libc.src.__support.str_to_integer
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
 )
 
 add_object_library(
   string_writer
   SRCS
     string_writer.cpp
   HDRS
     string_writer.h

libc/src/stdio/printf_core/char_converter.h

 //===-- String Converter for printf -----------------------------*- 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_STDIO_PRINTF_CORE_CHAR_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CHAR_CONVERTER_H
 
 #include "src/__support/CPP/string_view.h"
+#include "src/__support/common.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
-int inline convert_char(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_char(Writer *writer, const FormatSection &to_conv) {
   char c = to_conv.conv_val_raw;
 
   constexpr int string_len = 1;
 
   size_t padding_spaces =
       to_conv.min_width > string_len ? to_conv.min_width - string_len : 0;
 
   // If the padding is on the left side, write the spaces first.

libc/src/stdio/printf_core/converter_utils.h

 //===-- Shared Converter Utilities for printf -------------------*- 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_STDIO_PRINTF_CORE_CONVERTER_UTILS_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_UTILS_H
 
 #include "src/__support/CPP/limits.h"
+#include "src/__support/common.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-inline uintmax_t apply_length_modifier(uintmax_t num, LengthModifier lm) {
+LIBC_INLINE uintmax_t apply_length_modifier(uintmax_t num, LengthModifier lm) {
   switch (lm) {
   case LengthModifier::none:
     return num & cpp::numeric_limits<unsigned int>::max();
   case LengthModifier::l:
     return num & cpp::numeric_limits<unsigned long>::max();
   case LengthModifier::ll:
   case LengthModifier::L:
     return num & cpp::numeric_limits<unsigned long long>::max();

libc/src/stdio/printf_core/parser.h

 //===-- Format string parser for printf -------------------------*- 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_STDIO_PRINTF_CORE_PARSER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PARSER_H
 
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/arg_list.h"
+#include "src/__support/common.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/printf_config.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
   enum PrimaryType : uint8_t { Integer = 0, Float = 1, Pointer = 2 };
 
   // TypeDesc stores the information about a type that is relevant to printf in
   // a relatively compact manner.
   struct TypeDesc {
     uint8_t size;
     PrimaryType primary_type;
-    constexpr bool operator==(const TypeDesc &other) const {
+    LIBC_INLINE constexpr bool operator==(const TypeDesc &other) const {
       return (size == other.size) && (primary_type == other.primary_type);
     }
   };
 
   // Defined in printf_config.h
   static constexpr size_t DESC_ARR_LEN = LLVM_LIBC_PRINTF_INDEX_ARR_LEN;
 
   // desc_arr stores the sizes of the variables in the ArgList. This is used in
   // index mode to reduce repeated string parsing. The sizes are stored as
   // TypeDesc objects, which store the size as well as minimal type information.
   // This is necessary because some systems separate the floating point and
   // integer values in va_args.
   TypeDesc desc_arr[DESC_ARR_LEN] = {{0, Integer}};
 
   // TODO: Look into object stores for optimization.
 
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
 public:
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
-  Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args), args_start(args) {}
 #else
-  Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args) {}
 #endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its
   // variables stored in the format section.
   FormatSection get_next_section();
 
 private:
   // parse_flags parses the flags inside a format string. It assumes that
   // str[*local_pos] is inside a format specifier, and parses any flags it
   // finds. It returns a FormatFlags object containing the set of found flags
   // arithmetically or'd together. local_pos will be moved past any flags found.
   FormatFlags parse_flags(size_t *local_pos);
 
   // parse_length_modifier parses the length modifier inside a format string. It
   // assumes that str[*local_pos] is inside a format specifier. It returns a
   // LengthModifier with the length modifier it found. It will advance local_pos
   // after the format specifier if one is found.
   LengthModifier parse_length_modifier(size_t *local_pos);
 
   // get_next_arg_value gets the next value from the arg list as type T.
-  template <class T> T inline get_next_arg_value() {
+  template <class T> LIBC_INLINE T get_next_arg_value() {
     return args_cur.next_var<T>();
   }
 
   //----------------------------------------------------
   // INDEX MODE ONLY FUNCTIONS AFTER HERE:
   //----------------------------------------------------
 
 #ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
 
   // parse_index parses the index of a value inside a format string. It
   // assumes that str[*local_pos] points to character after a '%' or '*', and
   // returns 0 if there is no closing $, or if it finds no number. If it finds a
   // number, it will move local_pos past the end of the $, else it will not move
   // local_pos.
   size_t parse_index(size_t *local_pos);
 
-  template <typename T> static constexpr TypeDesc get_type_desc() {
+  template <typename T> LIBC_INLINE static constexpr TypeDesc get_type_desc() {
     if constexpr (cpp::is_same_v<T, void>) {
       return TypeDesc{0, PrimaryType::Integer};
     } else {
       constexpr bool isPointer = cpp::is_same_v<T, void *>;
       constexpr bool isFloat =
           cpp::is_same_v<T, double> || cpp::is_same_v<T, long double>;
       return TypeDesc{sizeof(T), isPointer ? PrimaryType::Pointer
                                  : isFloat ? PrimaryType::Float
                                            : PrimaryType::Integer};
     }
   }
 
-  void inline set_type_desc(size_t index, TypeDesc value) {
+  LIBC_INLINE void set_type_desc(size_t index, TypeDesc value) {
     if (index != 0 && index <= DESC_ARR_LEN)
       desc_arr[index - 1] = value;
   }
 
   // get_arg_value gets the value from the arg list at index (starting at 1).
   // This may require parsing the format string. An index of 0 is interpreted as
   // the next value.
-  template <class T> T inline get_arg_value(size_t index) {
+  template <class T> LIBC_INLINE T get_arg_value(size_t index) {
     if (!(index == 0 || index == args_index))
       args_to_index(index);
 
     set_type_desc(index, get_type_desc<T>());
 
     ++args_index;
     return get_next_arg_value<T>();
   }

libc/src/stdio/printf_core/string_converter.h

 //===-- String Converter for printf -----------------------------*- 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_STDIO_PRINTF_CORE_STRING_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_CONVERTER_H
 
 #include "src/__support/CPP/string_view.h"
+#include "src/__support/common.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-int inline convert_string(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_string(Writer *writer, const FormatSection &to_conv) {
   size_t string_len = 0;
 
   for (char *cur_str = reinterpret_cast<char *>(to_conv.conv_val_ptr);
        cur_str[string_len]; ++string_len) {
     ;
   }
 
   if (to_conv.precision >= 0 &&

libc/src/stdio/scanf_core/parser.h

 //===-- Format string parser for scanf -------------------------*- 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_STDIO_SCANF_CORE_PARSER_H
 #define LLVM_LIBC_SRC_STDIO_SCANF_CORE_PARSER_H
 
 #include "src/__support/arg_list.h"
+#include "src/__support/common.h"
 #include "src/stdio/scanf_core/core_structs.h"
 #include "src/stdio/scanf_core/scanf_config.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
 class Parser {
   const char *__restrict str;
 
   size_t cur_pos = 0;
   internal::ArgList args_cur;
 
 #ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
   // args_start stores the start of the va_args, which is used when a previous
   // argument is needed. In that case, we have to read the arguments from the
   // beginning since they don't support reading backwards.
   internal::ArgList args_start;
   size_t args_index = 1;
 #endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
 
 public:
 #ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
-  Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args), args_start(args) {}
 #else
-  Parser(const char *__restrict new_str, internal::ArgList &args)
+  LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args) {}
 #endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its
   // variables stored in the format section.
   FormatSection get_next_section();
 
 private:
   // parse_length_modifier parses the length modifier inside a format string. It
   // assumes that str[*local_pos] is inside a format specifier. It returns a
   // LengthModifier with the length modifier it found. It will advance local_pos
   // after the format specifier if one is found.
   LengthModifier parse_length_modifier(size_t *local_pos);
 
   // get_next_arg_value gets the next value from the arg list as type T.
-  template <class T> T inline get_next_arg_value() {
+  template <class T> LIBC_INLINE T get_next_arg_value() {
     return args_cur.next_var<T>();
   }
 
   //----------------------------------------------------
   // INDEX MODE ONLY FUNCTIONS AFTER HERE:
   //----------------------------------------------------
 
 #ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
 
   // parse_index parses the index of a value inside a format string. It
   // assumes that str[*local_pos] points to character after a '%' or '*', and
   // returns 0 if there is no closing $, or if it finds no number. If it finds a
   // number, it will move local_pos past the end of the $, else it will not move
   // local_pos.
   size_t parse_index(size_t *local_pos);
 
   // get_arg_value gets the value from the arg list at index (starting at 1).
   // This may require parsing the format string. An index of 0 is interpreted as
   // the next value.
-  template <class T> T inline get_arg_value(size_t index) {
+  template <class T> LIBC_INLINE T get_arg_value(size_t index) {
     if (!(index == 0 || index == args_index))
       args_to_index(index);
 
     ++args_index;
     return get_next_arg_value<T>();
   }
 
   // the ArgList can only return the next item in the list. This function is