[libc][NFC] Replace "inline" keyword with "LIBC_INLINE".

[sivachandra]

Summary

This is the first of patches doing similar cleanup. A section in the
code style doc has been added explaining where and how LIBC_INLINE is to
be used.

libc/docs/code_style.rst

 .. _code_style:
 
 ===================
 The libc code style
 ===================
 
+Naming style
+============
+
 For the large part, the libc project follows the general `coding standards of
 the LLVM project <https://llvm.org/docs/CodingStandards.html>`_. The libc
 project differs from that standard with respect to the naming style. The
 differences are as follows:
 
 #. **Non-const variables** - This includes function arguments, struct and
    class data members, non-const globals and local variables. They all use the
    ``snake_case`` style.
 #. **const and constexpr variables** - They use the capitlized
    ``SNAKE_CASE`` irrespective of whether they are local or global.
 #. **Function and methods** - They use the ``snake_case`` style like the
    non-const variables.
 #. **Internal type names** - These are types which are interal to the libc
-   implementation. They use the `CaptilizedCamelCase` style.
+   implementation. They use the ``CaptilizedCamelCase`` style.
 #. **Public names** - These are the names as prescribed by the standards and
    will follow the style as prescribed by the standards.
+
+Inline functions defined in header files
+========================================
+
+When defining functions inline in header files, we follow certain rules:
+
+#. The functions should not be given file-static linkage. There can be class
+   static methods defined inline however.
+#. Instead of using the ``inline`` keyword, they should be tagged with the
+   ``LIBC_INLINE`` macro defined in ``src/__support/common.h``. For example:
+
+   .. code-block:: c++
+
+     LIBC_INLINE ReturnType function_defined_inline(ArgType arg) {
+       ...
+     }
+
+#. The ``LIBC_INLINE`` tag should also be added to functions which have
+   definitions that are implicitly inline. Examples of such functions are
+   class methods (static and non-static) defined inline and ``constexpr``
+   functions.

libc/src/__support/CPP/CMakeLists.txt

DEPENDS
     .array
     .type_traits
 )
 
 add_header_library(
   string_view
   HDRS
     string_view.h
+  DEPENDS
+    libc.src.__support.common
 )
 
 add_header_library(
   stringstream
   HDRS
     stringstream.h
   DEPENDS
     .span

 add_object_library(
   new
   SRCS
     new.cpp
   HDRS
     new.h
   DEPENDS
     libc.include.stdlib
+    libc.src.__support.common
 )

libc/src/__support/CPP/new.h

 //===-- Libc specific custom operator new and delete ------------*- 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_CPP_NEW_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_NEW_H
 
+#include "src/__support/common.h"
+
 #include <stddef.h> // For size_t
 #include <stdlib.h> // For malloc, free etc.
 
 // Defining members in the std namespace is not preferred. But, we do it here
 // so that we can use it to define the operator new which takes std::align_val_t
 // argument.
 namespace std {
 
AllocChecker &operator=(bool status) {
     success = status;
     return *this;
   }
 
 public:
   AllocChecker() = default;
   operator bool() const { return success; }
 
-  static void *alloc(size_t s, AllocChecker &ac) {
+  LIBC_INLINE static void *alloc(size_t s, AllocChecker &ac) {
     void *mem = ::malloc(s);
     ac = (mem != nullptr);
     return mem;
   }
 
-  static void *aligned_alloc(size_t s, std::align_val_t align,
+  LIBC_INLINE static void *aligned_alloc(size_t s, std::align_val_t align,
                                          AllocChecker &ac) {
     void *mem = ::aligned_alloc(static_cast<size_t>(align), s);
     ac = (mem != nullptr);
     return mem;
   }
 };
 
 } // namespace __llvm_libc
 
-inline void *operator new(size_t size, __llvm_libc::AllocChecker &ac) noexcept {
+LIBC_INLINE void *operator new(size_t size,
+                               __llvm_libc::AllocChecker &ac) noexcept {
   return __llvm_libc::AllocChecker::alloc(size, ac);
 }
 
-inline void *operator new(size_t size, std::align_val_t align,
+LIBC_INLINE void *operator new(size_t size, std::align_val_t align,
                                __llvm_libc::AllocChecker &ac) noexcept {
   return __llvm_libc::AllocChecker::aligned_alloc(size, align, ac);
 }
 
-inline void *operator new[](size_t size,
+LIBC_INLINE void *operator new[](size_t size,
                                  __llvm_libc::AllocChecker &ac) noexcept {
   return __llvm_libc::AllocChecker::alloc(size, ac);
 }
 
-inline void *operator new[](size_t size, std::align_val_t align,
+LIBC_INLINE void *operator new[](size_t size, std::align_val_t align,
                                  __llvm_libc::AllocChecker &ac) noexcept {
   return __llvm_libc::AllocChecker::aligned_alloc(size, align, ac);
 }
 
 // The ideal situation would be to define the various flavors of operator delete
-// inline like we do with operator new above. However, since we need operator
+// inlinelike we do with operator new above. However, since we need operator
 // delete prototypes to match those specified by the C++ standard, we cannot
 // define them inline as the C++ standard does not allow inline definitions of
 // replacement operator delete implementations. Note also that we assign a
 // special linkage name to each of these replacement operator delete functions.
 // This is because, if we do not give them a special libc internal linkage name,
 // they will replace operator delete for the entire application. Including this
 // header file in all libc source files where operator delete is called ensures
 // that only libc call sites use these replacement operator delete functions.

libc/src/__support/CPP/string_view.h

 //===-- Standalone implementation std::string_view --------------*- 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_CPP_STRINGVIEW_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_STRINGVIEW_H
 
+#include "src/__support/common.h"
+
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace cpp {
 
 // This is very simple alternate of the std::string_view 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 string_view {
 private:
   const char *Data;
   size_t Len;
 
   static size_t min(size_t A, size_t B) { return A <= B ? A : B; }
 
-  static int compareMemory(const char *Lhs, const char *Rhs, size_t Length) {
+  LIBC_INLINE static int compareMemory(const char *Lhs, const char *Rhs,
+                                       size_t Length) {
     for (size_t I = 0; I < Length; ++I)
       if (int Diff = (int)Lhs[I] - (int)Rhs[I])
         return Diff;
     return 0;
   }
 
-  static constexpr size_t length(const char *Str) {
+  LIBC_INLINE static constexpr size_t length(const char *Str) {
     for (const char *End = Str;; ++End)
       if (*End == '\0')
         return End - Str;
   }
 
-  bool equals(string_view Other) const {
+  LIBC_INLINE bool equals(string_view Other) const {
     return (Len == Other.Len &&
             compareMemory(Data, Other.Data, Other.Len) == 0);
   }
 
 public:
   using value_type = char;
   using size_type = size_t;
   using difference_type = ptrdiff_t;
   using pointer = char *;
   using const_pointer = const char *;
   using reference = char &;
   using const_reference = const char &;
   using const_iterator = char *;
   using iterator = const_iterator;
 
   // special value equal to the maximum value representable by the type
   // size_type.
   inline static constexpr size_t npos = -1;
 
-  constexpr string_view() : Data(nullptr), Len(0) {}
+  LIBC_INLINE constexpr string_view() : Data(nullptr), Len(0) {}
 
   // Assumes Str is a null-terminated string. The length of the string does
   // not include the terminating null character.
   // Preconditions: [Str, Str + !length(Str)) is a valid range.
-  constexpr string_view(const char *Str) : Data(Str), Len(length(Str)) {}
+  LIBC_INLINE constexpr string_view(const char *Str)
+      : Data(Str), Len(length(Str)) {}
 
   // Preconditions: [Str, Str + N) is a valid range.
-  constexpr string_view(const char *Str, size_t N) : Data(Str), Len(N) {}
+  LIBC_INLINE constexpr string_view(const char *Str, size_t N)
+      : Data(Str), Len(N) {}
 
-  constexpr const char *data() const { return Data; }
+  LIBC_INLINE constexpr const char *data() const { return Data; }
 
   // Returns the size of the string_view.
-  constexpr size_t size() const { return Len; }
+  LIBC_INLINE constexpr size_t size() const { return Len; }
 
   // Returns whether the string_view is empty.
-  constexpr bool empty() const { return Len == 0; }
+  LIBC_INLINE constexpr bool empty() const { return Len == 0; }
 
   // Returns an iterator to the first character of the view.
-  const char *begin() const { return Data; }
+  LIBC_INLINE const char *begin() const { return Data; }
 
   // Returns an iterator to the character following the last character of the
   // view.
-  const char *end() const { return Data + Len; }
+  LIBC_INLINE const char *end() const { return Data + Len; }
 
   // Returns a const reference to the character at specified location pos.
   // No bounds checking is performed: the behavior is undefined if pos >=
   // size().
-  constexpr const char &operator[](size_t Index) const { return Data[Index]; }
+  LIBC_INLINE constexpr const char &operator[](size_t Index) const {
+    return Data[Index];
+  }
 
   /// compare - Compare two strings; the result is -1, 0, or 1 if this string
   /// is lexicographically less than, equal to, or greater than the \p Other.
-  int compare(string_view Other) const {
+  LIBC_INLINE int compare(string_view Other) const {
     // Check the prefix for a mismatch.
     if (int Res = compareMemory(Data, Other.Data, min(Len, Other.Len)))
       return Res < 0 ? -1 : 1;
     // Otherwise the prefixes match, so we only need to check the lengths.
     if (Len == Other.Len)
       return 0;
     return Len < Other.Len ? -1 : 1;
   }
 
-  inline bool operator==(string_view Other) const { return equals(Other); }
-  inline bool operator!=(string_view Other) const { return !(*this == Other); }
-  inline bool operator<(string_view Other) const {
+  LIBC_INLINE bool operator==(string_view Other) const { return equals(Other); }
+  LIBC_INLINE bool operator!=(string_view Other) const {
+    return !(*this == Other);
+  }
+  LIBC_INLINE bool operator<(string_view Other) const {
     return compare(Other) == -1;
   }
-  inline bool operator<=(string_view Other) const {
+  LIBC_INLINE bool operator<=(string_view Other) const {
     return compare(Other) != 1;
   }
-  inline bool operator>(string_view Other) const { return compare(Other) == 1; }
-  inline bool operator>=(string_view Other) const {
+  LIBC_INLINE bool operator>(string_view Other) const {
+    return compare(Other) == 1;
+  }
+  LIBC_INLINE bool operator>=(string_view Other) const {
     return compare(Other) != -1;
   }
 
   // Moves the start of the view forward by n characters.
   // The behavior is undefined if n > size().
-  void remove_prefix(size_t N) {
+  LIBC_INLINE void remove_prefix(size_t N) {
     Len -= N;
     Data += N;
   }
 
   // Moves the end of the view back by n characters.
   // The behavior is undefined if n > size().
-  void remove_suffix(size_t N) { Len -= N; }
+  LIBC_INLINE void remove_suffix(size_t N) { Len -= N; }
 
   // Check if this string starts with the given Prefix.
-  bool starts_with(string_view Prefix) const {
+  LIBC_INLINE bool starts_with(string_view Prefix) const {
     return Len >= Prefix.Len &&
            compareMemory(Data, Prefix.Data, Prefix.Len) == 0;
   }
 
   // Check if this string starts with the given Prefix.
-  bool starts_with(const char Prefix) const {
+  LIBC_INLINE bool starts_with(const char Prefix) const {
     return !empty() && front() == Prefix;
   }
 
   // Check if this string ends with the given Prefix.
-  bool ends_with(const char Suffix) const {
+  LIBC_INLINE bool ends_with(const char Suffix) const {
     return !empty() && back() == Suffix;
   }
 
   // Check if this string ends with the given Suffix.
-  bool ends_with(string_view Suffix) const {
+  LIBC_INLINE bool ends_with(string_view Suffix) const {
     return Len >= Suffix.Len &&
            compareMemory(end() - Suffix.Len, Suffix.Data, Suffix.Len) == 0;
   }
 
   // Return a reference to the substring from [Start, Start + N).
   //
   // Start The index of the starting character in the substring; if the index is
   // npos or greater than the length of the string then the empty substring will
   // be returned.
   //
   // N The number of characters to included in the substring. If N exceeds the
   // number of characters remaining in the string, the string suffix (starting
   // with Start) will be returned.
-  string_view substr(size_t Start, size_t N = npos) const {
+  LIBC_INLINE string_view substr(size_t Start, size_t N = npos) const {
     Start = min(Start, Len);
     return string_view(Data + Start, min(N, Len - Start));
   }
 
   // front - Get the first character in the string.
-  char front() const { return Data[0]; }
+  LIBC_INLINE char front() const { return Data[0]; }
 
   // back - Get the last character in the string.
-  char back() const { return Data[Len - 1]; }
+  LIBC_INLINE char back() const { return Data[Len - 1]; }
 
   // Finds the first occurence of c in this view, starting at position From.
-  size_t find_first_of(const char c, size_t From = 0) const {
+  LIBC_INLINE size_t find_first_of(const char c, size_t From = 0) const {
     for (size_t Pos = From; Pos < size(); ++Pos)
       if ((*this)[Pos] == c)
         return Pos;
     return npos;
   }
 
   // Finds the last occurence of c in this view, ending at position End.
-  size_t find_last_of(const char c, size_t End = npos) const {
+  LIBC_INLINE size_t find_last_of(const char c, size_t End = npos) const {
     End = End >= size() ? size() : End + 1;
     for (; End > 0; --End)
       if ((*this)[End - 1] == c)
         return End - 1;
     return npos;
   }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_STRINGVIEW_H

libc/src/__support/FPUtil/CMakeLists.txt

 
 add_header_library(
   normal_float
   HDRS
     NormalFloat.h
   DEPENDS
     .fp_bits
     libc.src.__support.CPP.type_traits
+    libc.src.__support.common
 )
 
 add_header_library(
   manipulation_functions
   HDRS
     ManipulationFunctions.h
   DEPENDS
     .fp_bits

libc/src/__support/FPUtil/NormalFloat.h

 //===-- A class to store a normalized floating point number -----*- 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_NORMAL_FLOAT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
 
 #include "FPBits.h"
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/common.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // A class which stores the normalized form of a floating point value.
 // The special IEEE-754 bits patterns of Zero, infinity and NaNs are
template <typename T> struct NormalFloat {
   UIntType mantissa;
   // We want |UIntType| to have atleast one bit more than the actual mantissa
   // bit width to accommodate the implicit 1 value.
   static_assert(sizeof(UIntType) * 8 >= MantissaWidth<T>::VALUE + 1,
                 "Bad type for mantissa in NormalFloat.");
 
   bool sign;
 
-  NormalFloat(int32_t e, UIntType m, bool s)
+  LIBC_INLINE NormalFloat(int32_t e, UIntType m, bool s)
       : exponent(e), mantissa(m), sign(s) {
     if (mantissa >= ONE)
       return;
 
     unsigned normalization_shift = evaluate_normalization_shift(mantissa);
     mantissa = mantissa << normalization_shift;
     exponent -= normalization_shift;
   }
 
-  explicit NormalFloat(T x) { init_from_bits(FPBits<T>(x)); }
+  LIBC_INLINE explicit NormalFloat(T x) { init_from_bits(FPBits<T>(x)); }
 
-  explicit NormalFloat(FPBits<T> bits) { init_from_bits(bits); }
+  LIBC_INLINE explicit NormalFloat(FPBits<T> bits) { init_from_bits(bits); }
 
   // Compares this normalized number with another normalized number.
   // Returns -1 is this number is less than |other|, 0 if this number is equal
   // to |other|, and 1 if this number is greater than |other|.
-  int cmp(const NormalFloat<T> &other) const {
+  LIBC_INLINE int cmp(const NormalFloat<T> &other) const {
     if (sign != other.sign)
       return sign ? -1 : 1;
 
     if (exponent > other.exponent) {
       return sign ? -1 : 1;
     } else if (exponent == other.exponent) {
       if (mantissa > other.mantissa)
         return sign ? -1 : 1;
       else if (mantissa == other.mantissa)
         return 0;
       else
         return sign ? 1 : -1;
     } else {
       return sign ? 1 : -1;
     }
   }
 
   // Returns a new normalized floating point number which is equal in value
   // to this number multiplied by 2^e. That is:
   //     new = this *  2^e
-  NormalFloat<T> mul2(int e) const {
+  LIBC_INLINE NormalFloat<T> mul2(int e) const {
     NormalFloat<T> result = *this;
     result.exponent += e;
     return result;
   }
 
-  operator T() const {
+  LIBC_INLINE operator T() const {
     int biased_exponent = exponent + FPBits<T>::EXPONENT_BIAS;
     // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
     constexpr int MAX_EXPONENT_VALUE = (1 << ExponentWidth<T>::VALUE) - 2;
     if (biased_exponent > MAX_EXPONENT_VALUE) {
       return sign ? T(FPBits<T>::neg_inf()) : T(FPBits<T>::inf());
     }
 
     FPBits<T> result(T(0.0));
LIBC_INLINE operator T() const {
     }
 
     result.set_unbiased_exponent(exponent + FPBits<T>::EXPONENT_BIAS);
     result.set_mantissa(mantissa);
     return T(result);
   }
 
 private:
-  void init_from_bits(FPBits<T> bits) {
+  LIBC_INLINE void init_from_bits(FPBits<T> bits) {
     sign = bits.get_sign();
 
     if (bits.is_inf_or_nan() || bits.is_zero()) {
       // Ignore special bit patterns. Implementations deal with them separately
       // anyway so this should not be a problem.
       exponent = 0;
       mantissa = 0;
       return;
     }
 
     // Normalize subnormal numbers.
     if (bits.get_unbiased_exponent() == 0) {
       unsigned shift = evaluate_normalization_shift(bits.get_mantissa());
       mantissa = UIntType(bits.get_mantissa()) << shift;
       exponent = 1 - FPBits<T>::EXPONENT_BIAS - shift;
     } else {
       exponent = bits.get_unbiased_exponent() - FPBits<T>::EXPONENT_BIAS;
       mantissa = ONE | bits.get_mantissa();
     }
   }
 
-  unsigned evaluate_normalization_shift(UIntType m) {
+  LIBC_INLINE unsigned evaluate_normalization_shift(UIntType m) {
     unsigned shift = 0;
     for (; (ONE & m) == 0 && (shift < MantissaWidth<T>::VALUE);
          m <<= 1, ++shift)
       ;
     return shift;
   }
 };
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 template <>
-inline void NormalFloat<long double>::init_from_bits(FPBits<long double> bits) {
+LIBC_INLINE void
+NormalFloat<long double>::init_from_bits(FPBits<long double> bits) {
   sign = bits.get_sign();
 
   if (bits.is_inf_or_nan() || bits.is_zero()) {
     // Ignore special bit patterns. Implementations deal with them separately
     // anyway so this should not be a problem.
     exponent = 0;
     mantissa = 0;
     return;
if (bits.get_implicit_bit() == 0) {
       mantissa = 0;
     } else {
       exponent = bits.get_unbiased_exponent() - 16383;
       mantissa = ONE | bits.get_mantissa();
     }
   }
 }
 
-template <> inline NormalFloat<long double>::operator long double() const {
+template <> LIBC_INLINE NormalFloat<long double>::operator long double() const {
   int biased_exponent = exponent + FPBits<long double>::EXPONENT_BIAS;
   // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
   constexpr int MAX_EXPONENT_VALUE =
       (1 << ExponentWidth<long double>::VALUE) - 2;
   if (biased_exponent > MAX_EXPONENT_VALUE) {
     return sign ? FPBits<long double>::neg_inf() : FPBits<long double>::inf();
   }
 

libc/src/__support/FPUtil/double_double.h

 //===-- Utilities for double-double data type. ------------------*- 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_DOUBLEDOUBLE_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DOUBLEDOUBLE_H
 
 #include "multiply_add.h"
+#include "src/__support/common.h"
 #include "src/__support/number_pair.h"
 
 namespace __llvm_libc::fputil {
 
 using DoubleDouble = __llvm_libc::NumberPair<double>;
 
 // Assumption: |a| >= |b|
-constexpr inline DoubleDouble exact_add(double a, double b) {
+LIBC_INLINE constexpr DoubleDouble exact_add(double a, double b) {
   DoubleDouble r{0.0, 0.0};
   r.hi = a + b;
   double t = r.hi - a;
   r.lo = b - t;
   return r;
 }
 
 // Assumption: |a.hi| >= |b.hi|
-constexpr inline DoubleDouble add(DoubleDouble a, DoubleDouble b) {
+LIBC_INLINE constexpr DoubleDouble add(DoubleDouble a, DoubleDouble b) {
   DoubleDouble r = exact_add(a.hi, b.hi);
   double lo = a.lo + b.lo;
   return exact_add(r.hi, r.lo + lo);
 }
 
 // Assumption: |a.hi| >= |b|
-constexpr inline DoubleDouble add(DoubleDouble a, double b) {
+LIBC_INLINE constexpr DoubleDouble add(DoubleDouble a, double b) {
   DoubleDouble r = exact_add(a.hi, b);
   return exact_add(r.hi, r.lo + a.lo);
 }
 
 // TODO(lntue): add a correct multiplication when FMA instructions are not
 // available.
-inline DoubleDouble exact_mult(double a, double b) {
+LIBC_INLINE DoubleDouble exact_mult(double a, double b) {
   DoubleDouble r{0.0, 0.0};
   r.hi = a * b;
   r.lo = fputil::multiply_add(a, b, -r.hi);
   return r;
 }
 
 } // namespace __llvm_libc::fputil
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DOUBLEDOUBLE_H

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

 #define REGISTER_CONSTRAINT_5 REGISTER_CONSTRAINT_4, "r"(x4)
 #define REGISTER_CONSTRAINT_6 REGISTER_CONSTRAINT_5, "r"(x5)
 
 #define SYSCALL_INSTR(input_constraint)                                        \
   LIBC_INLINE_ASM("svc 0" : "=r"(x0) : input_constraint : "memory", "cc")
 
 namespace __llvm_libc {
 
-__attribute__((always_inline)) inline long syscall_impl(long number) {
+LIBC_INLINE long syscall_impl(long number) {
   REGISTER_DECL_0;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_0);
   return x0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number,
-                                                        long arg1) {
+LIBC_INLINE long syscall_impl(long number, long arg1) {
   REGISTER_DECL_1;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_1);
   return x0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2) {
   REGISTER_DECL_2;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_2);
   return x0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3) {
   REGISTER_DECL_3;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_3);
   return x0;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long number, long arg1, long arg2, long arg3, long arg4) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
+                              long arg4) {
   REGISTER_DECL_4;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_4);
   return x0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3,
-                                                        long arg4, long arg5) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
   REGISTER_DECL_5;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_5);
   return x0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3,
-                                                        long arg4, long arg5,
-                                                        long arg6) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
+                              long arg4, long arg5, long arg6) {
   REGISTER_DECL_6;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_6);
   return x0;
 }
 
 } // namespace __llvm_libc
 
 #undef REGISTER_DECL_0

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

 #define REGISTER_CONSTRAINT_5 REGISTER_CONSTRAINT_4, "r"(r4)
 #define REGISTER_CONSTRAINT_6 REGISTER_CONSTRAINT_5, "r"(r5)
 
 #define SYSCALL_INSTR(input_constraint)                                        \
   LIBC_INLINE_ASM("svc 0" : "=r"(r0) : input_constraint : "memory", "cc")
 
 namespace __llvm_libc {
 
-__attribute__((always_inline)) inline long syscall_impl(long number) {
+LIBC_INLINE long syscall_impl(long number) {
   REGISTER_DECL_0;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_0);
   return r0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number,
-                                                        long arg1) {
+LIBC_INLINE long syscall_impl(long number, long arg1) {
   REGISTER_DECL_1;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_1);
   return r0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2) {
   REGISTER_DECL_2;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_2);
   return r0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3) {
   REGISTER_DECL_3;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_3);
   return r0;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long number, long arg1, long arg2, long arg3, long arg4) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
+                              long arg4) {
   REGISTER_DECL_4;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_4);
   return r0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3,
-                                                        long arg4, long arg5) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
   REGISTER_DECL_5;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_5);
   return r0;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long number, long arg1,
-                                                        long arg2, long arg3,
-                                                        long arg4, long arg5,
-                                                        long arg6) {
+LIBC_INLINE long syscall_impl(long number, long arg1, long arg2, long arg3,
+                              long arg4, long arg5, long arg6) {
   REGISTER_DECL_6;
   SYSCALL_INSTR(REGISTER_CONSTRAINT_6);
   return r0;
 }
 
 } // namespace __llvm_libc
 
 #undef REGISTER_DECL_0

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

 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_X86_64_SYSCALL_H
 
 #include "src/__support/common.h"
 
 #define SYSCALL_CLOBBER_LIST "rcx", "r11", "memory"
 
 namespace __llvm_libc {
 
-__attribute__((always_inline)) inline long syscall_impl(long __number) {
+LIBC_INLINE long syscall_impl(long __number) {
   long retcode;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long syscall_impl(long __number,
-                                                        long __arg1) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1) {
   long retcode;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long __number, long __arg1, long __arg2) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1, long __arg2) {
   long retcode;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1), "S"(__arg2)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long __number, long __arg1, long __arg2, long __arg3) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1, long __arg2,
+                              long __arg3) {
   long retcode;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1), "S"(__arg2), "d"(__arg3)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long __number, long __arg1, long __arg2, long __arg3,
-             long __arg4) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1, long __arg2,
+                              long __arg3, long __arg4) {
   long retcode;
   register long r10 __asm__("r10") = __arg4;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1), "S"(__arg2), "d"(__arg3),
                     "r"(r10)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long __number, long __arg1, long __arg2, long __arg3, long __arg4,
-             long __arg5) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1, long __arg2,
+                              long __arg3, long __arg4, long __arg5) {
   long retcode;
   register long r10 __asm__("r10") = __arg4;
   register long r8 __asm__("r8") = __arg5;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1), "S"(__arg2), "d"(__arg3),
                     "r"(r10), "r"(r8)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
-__attribute__((always_inline)) inline long
-syscall_impl(long __number, long __arg1, long __arg2, long __arg3, long __arg4,
-             long __arg5, long __arg6) {
+LIBC_INLINE long syscall_impl(long __number, long __arg1, long __arg2,
+                              long __arg3, long __arg4, long __arg5,
+                              long __arg6) {
   long retcode;
   register long r10 __asm__("r10") = __arg4;
   register long r8 __asm__("r8") = __arg5;
   register long r9 __asm__("r9") = __arg6;
   LIBC_INLINE_ASM("syscall"
                   : "=a"(retcode)
                   : "a"(__number), "D"(__arg1), "S"(__arg2), "d"(__arg3),
                     "r"(r10), "r"(r8), "r"(r9)
                   : SYSCALL_CLOBBER_LIST);
   return retcode;
 }
 
 #undef SYSCALL_CLOBBER_LIST
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_X86_64_SYSCALL_H

libc/src/__support/builtin_wrappers.h

 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> LIBC_INLINE int clz(T val);
-template <> inline int clz<unsigned int>(unsigned int val) {
+template <> LIBC_INLINE int clz<unsigned int>(unsigned int val) {
   return __builtin_clz(val);
 }
-template <> inline int clz<unsigned long int>(unsigned long int val) {
+template <> LIBC_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) {
+template <>
+LIBC_INLINE int clz<unsigned long long int>(unsigned long long int val) {
   return __builtin_clzll(val);
 }
 
 template <typename T> LIBC_INLINE int ctz(T val);
-template <> inline int ctz<unsigned int>(unsigned int val) {
+template <> LIBC_INLINE int ctz<unsigned int>(unsigned int val) {
   return __builtin_ctz(val);
 }
-template <> inline int ctz<unsigned long int>(unsigned long int val) {
+template <> LIBC_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) {
+template <>
+LIBC_INLINE int ctz<unsigned long long int>(unsigned long long int val) {
   return __builtin_ctzll(val);
 }
 } // namespace __internal
 
 template <typename T> LIBC_INLINE int safe_ctz(T val) {
   return __internal::correct_zero(val, __internal::ctz(val));
 }
 
 template <typename T> LIBC_INLINE int unsafe_ctz(T val) {
   return __internal::ctz(val);
 }
 
 template <typename T> LIBC_INLINE int safe_clz(T val) {
   return __internal::correct_zero(val, __internal::clz(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_INLINE constexpr cpp::enable_if_t<
     cpp::is_integral_v<T> && cpp::is_unsigned_v<T>, SumCarry<T>>
 add_with_carry(T a, T b, T carry_in) {
   T tmp = a + carry_in;
   T sum = b + tmp;
   T carry_out = (sum < b) || (tmp < a);
   return {sum, carry_out};
 }
 
 #if LLVM_LIBC_HAS_BUILTIN(__builtin_addc)
 // https://clang.llvm.org/docs/LanguageExtensions.html#multiprecision-arithmetic-builtins
 
 template <>
-inline SumCarry<unsigned char>
+LIBC_INLINE SumCarry<unsigned char>
 add_with_carry<unsigned char>(unsigned char a, unsigned char b,
                               unsigned char carry_in) {
   SumCarry<unsigned char> result{0, 0};
   result.sum = __builtin_addcb(a, b, carry_in, &result.carry);
   return result;
 }
 
 template <>
-inline SumCarry<unsigned short>
+LIBC_INLINE SumCarry<unsigned short>
 add_with_carry<unsigned short>(unsigned short a, unsigned short b,
                                unsigned short carry_in) {
   SumCarry<unsigned short> result{0, 0};
   result.sum = __builtin_addcs(a, b, carry_in, &result.carry);
   return result;
 }
 
 template <>
-inline SumCarry<unsigned int>
+LIBC_INLINE SumCarry<unsigned int>
 add_with_carry<unsigned int>(unsigned int a, unsigned int b,
                              unsigned int carry_in) {
   SumCarry<unsigned int> result{0, 0};
   result.sum = __builtin_addc(a, b, carry_in, &result.carry);
   return result;
 }
 
 template <>
-inline SumCarry<unsigned long>
+LIBC_INLINE SumCarry<unsigned long>
 add_with_carry<unsigned long>(unsigned long a, unsigned long b,
                               unsigned long carry_in) {
   SumCarry<unsigned long> result{0, 0};
   result.sum = __builtin_addcl(a, b, carry_in, &result.carry);
   return result;
 }
 
 template <>
-inline SumCarry<unsigned long long>
+LIBC_INLINE SumCarry<unsigned long long>
 add_with_carry<unsigned long long>(unsigned long long a, unsigned long long b,
                                    unsigned long long carry_in) {
   SumCarry<unsigned long long> result{0, 0};
   result.sum = __builtin_addcll(a, b, carry_in, &result.carry);
   return result;
 }
 
 #endif // LLVM_LIBC_HAS_BUILTIN(__builtin_addc)
 
 // Subtract with borrow
 DEFINE_NAMED_PAIR_TEMPLATE(DiffBorrow, diff, borrow);
 
 template <typename T>
-inline constexpr cpp::enable_if_t<
+LIBC_INLINE constexpr cpp::enable_if_t<
     cpp::is_integral_v<T> && cpp::is_unsigned_v<T>, DiffBorrow<T>>
 sub_with_borrow(T a, T b, T borrow_in) {
   T tmp = a - b;
   T diff = tmp - borrow_in;
   T borrow_out = (diff > tmp) || (tmp > a);
   return {diff, borrow_out};
 }
 
 #if LLVM_LIBC_HAS_BUILTIN(__builtin_subc)
 // https://clang.llvm.org/docs/LanguageExtensions.html#multiprecision-arithmetic-builtins
 
 template <>
-inline DiffBorrow<unsigned char>
+LIBC_INLINE DiffBorrow<unsigned char>
 sub_with_borrow<unsigned char>(unsigned char a, unsigned char b,
                                unsigned char borrow_in) {
   DiffBorrow<unsigned char> result{0, 0};
   result.diff = __builtin_subcb(a, b, borrow_in, &result.borrow);
   return result;
 }
 
 template <>
-inline DiffBorrow<unsigned short>
+LIBC_INLINE DiffBorrow<unsigned short>
 sub_with_borrow<unsigned short>(unsigned short a, unsigned short b,
                                 unsigned short borrow_in) {
   DiffBorrow<unsigned short> result{0, 0};
   result.diff = __builtin_subcs(a, b, borrow_in, &result.borrow);
   return result;
 }
 
 template <>
-inline DiffBorrow<unsigned int>
+LIBC_INLINE DiffBorrow<unsigned int>
 sub_with_borrow<unsigned int>(unsigned int a, unsigned int b,
                               unsigned int borrow_in) {
   DiffBorrow<unsigned int> result{0, 0};
   result.diff = __builtin_subc(a, b, borrow_in, &result.borrow);
   return result;
 }
 
 template <>
-inline DiffBorrow<unsigned long>
+LIBC_INLINE DiffBorrow<unsigned long>
 sub_with_borrow<unsigned long>(unsigned long a, unsigned long b,
                                unsigned long borrow_in) {
   DiffBorrow<unsigned long> result{0, 0};
   result.diff = __builtin_subcl(a, b, borrow_in, &result.borrow);
   return result;
 }
 
 template <>
-inline DiffBorrow<unsigned long long>
+LIBC_INLINE DiffBorrow<unsigned long long>
 sub_with_borrow<unsigned long long>(unsigned long long a, unsigned long long b,
                                     unsigned long long borrow_in) {
   DiffBorrow<unsigned long long> result{0, 0};
   result.diff = __builtin_subcll(a, b, borrow_in, &result.borrow);
   return result;
 }
 
 #endif // LLVM_LIBC_HAS_BUILTIN(__builtin_subc)
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H

libc/src/__support/endian.h

 //===-- Endianness support --------------------------------------*- 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_ENDIAN_H
 #define LLVM_LIBC_SRC_SUPPORT_ENDIAN_H
 
+#include "common.h"
+
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // We rely on compiler preprocessor defines to allow for cross compilation.
 #if !defined(__BYTE_ORDER__) || !defined(__ORDER_LITTLE_ENDIAN__) ||           \
     !defined(__ORDER_BIG_ENDIAN__)
 #error "Missing preprocessor definitions for endianness detection."
template <unsigned ORDER> struct Endian {
   static constexpr const bool IS_BIG = ORDER == __ORDER_BIG_ENDIAN__;
   template <typename T> static T to_big_endian(T value);
   template <typename T> static T to_little_endian(T value);
 };
 
 // Little Endian specializations
 template <>
 template <>
-inline uint8_t
+LIBC_INLINE uint8_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
-inline uint8_t
+LIBC_INLINE uint8_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
-inline uint16_t
+LIBC_INLINE uint16_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint16_t>(uint16_t v) {
   return __builtin_bswap16(v);
 }
 template <>
 template <>
-inline uint16_t
+LIBC_INLINE uint16_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint16_t>(uint16_t v) {
   return v;
 }
 template <>
 template <>
-inline uint32_t
+LIBC_INLINE uint32_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint32_t>(uint32_t v) {
   return __builtin_bswap32(v);
 }
 template <>
 template <>
-inline uint32_t
+LIBC_INLINE uint32_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint32_t>(uint32_t v) {
   return v;
 }
 template <>
 template <>
-inline uint64_t
+LIBC_INLINE uint64_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint64_t>(uint64_t v) {
   return __builtin_bswap64(v);
 }
 template <>
 template <>
-inline uint64_t
+LIBC_INLINE uint64_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_little_endian<uint64_t>(uint64_t v) {
   return v;
 }
 
 // Big Endian specializations
 template <>
 template <>
-inline uint8_t Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
+LIBC_INLINE uint8_t
+Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
-inline uint8_t
+LIBC_INLINE uint8_t
 Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>
 template <>
-inline uint16_t
+LIBC_INLINE uint16_t
 Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint16_t>(uint16_t v) {
   return v;
 }
 template <>
 template <>
-inline uint16_t
+LIBC_INLINE uint16_t
 Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint16_t>(uint16_t v) {
   return __builtin_bswap16(v);
 }
 template <>
 template <>
-inline uint32_t
+LIBC_INLINE uint32_t
 Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint32_t>(uint32_t v) {
   return v;
 }
 template <>
 template <>
-inline uint32_t
+LIBC_INLINE uint32_t
 Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint32_t>(uint32_t v) {
   return __builtin_bswap32(v);
 }
 template <>
 template <>
-inline uint64_t
+LIBC_INLINE uint64_t
 Endian<__ORDER_BIG_ENDIAN__>::to_big_endian<uint64_t>(uint64_t v) {
   return v;
 }
 template <>
 template <>
-inline uint64_t
+LIBC_INLINE uint64_t
 Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint64_t>(uint64_t v) {
   return __builtin_bswap64(v);
 }
 
 } // namespace internal
 
 using Endian = internal::Endian<__BYTE_ORDER__>;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ENDIAN_H

libc/src/stdio/printf_core/CMakeLists.txt

add_object_library(
   DEPENDS
     .writer
     .core_structs
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.fenv_impl
+    libc.src.__support.common
     libc.src.__support.uint
     libc.src.__support.uint128
     libc.src.__support.integer_to_string
     libc.src.__support.float_to_string
 )
 
 
 add_object_library(

libc/src/stdio/printf_core/float_dec_converter.h

 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_DEC_CONVERTER_H
 
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/UInt.h"
 #include "src/__support/UInt128.h"
+#include "src/__support/common.h"
 #include "src/__support/float_to_string.h"
 #include "src/__support/integer_to_string.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/float_inf_nan_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 using MantissaInt = fputil::FPBits<long double>::UIntType;
 
 // Returns true if value is divisible by 2^p.
-constexpr inline bool multiple_of_power_of_2(const uint64_t value,
+LIBC_INLINE constexpr bool multiple_of_power_of_2(const uint64_t value,
                                                   const uint32_t p) {
   return (value & ((uint64_t(1) << p) - 1)) == 0;
 }
 
 constexpr size_t BLOCK_SIZE = 9;
 constexpr uint32_t MAX_BLOCK = 999999999;
 
 // constexpr size_t BLOCK_SIZE = 18;
 // constexpr uint32_t MAX_BLOCK = 999999999999999999;
public:
   }
 
   int right_pad() {
     return padding_writer.write_right_padding(writer, total_digits);
   }
 };
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-int inline convert_float_decimal_typed(Writer *writer,
+LIBC_INLINE int convert_float_decimal_typed(Writer *writer,
                                             const FormatSection &to_conv,
                                             fputil::FPBits<T> float_bits) {
   // signed because later we use -MANT_WIDTH
   constexpr int32_t MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   bool is_negative = float_bits.get_sign();
   int exponent = float_bits.get_exponent();
 
   char sign_char = 0;
 
   if (is_negative)
LIBC_INLINE int convert_float_decimal_typed(Writer *writer,
   } else {
     RET_IF_RESULT_NEGATIVE(float_writer.write_zeroes(precision));
   }
   RET_IF_RESULT_NEGATIVE(float_writer.right_pad());
   return WRITE_OK;
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
-int inline convert_float_dec_exp_typed(Writer *writer,
+LIBC_INLINE int convert_float_dec_exp_typed(Writer *writer,
                                             const FormatSection &to_conv,
                                             fputil::FPBits<T> float_bits) {
   // signed because later we use -MANT_WIDTH
   constexpr int32_t MANT_WIDTH = fputil::MantissaWidth<T>::VALUE;
   bool is_negative = float_bits.get_sign();
   int exponent = float_bits.get_exponent();
   MantissaInt mantissa = float_bits.get_explicit_mantissa();
 
   const char a = (to_conv.conv_name & 32) | 'A';
 
LIBC_INLINE int convert_float_dec_exp_typed(Writer *writer,
   }
   RET_IF_RESULT_NEGATIVE(float_writer.write_last_block_exp(
       digits, maximum, round, final_exponent, a + 'E' - 'A'));
 
   RET_IF_RESULT_NEGATIVE(float_writer.right_pad());
   return WRITE_OK;
 }
 
-int inline convert_float_decimal(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_float_decimal(Writer *writer,
+                                      const FormatSection &to_conv) {
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_decimal_typed<long double>(writer, to_conv,
                                                       float_bits);
     }
   } else {
     fputil::FPBits<double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_decimal_typed<double>(writer, to_conv, float_bits);
     }
   }
 
   return convert_inf_nan(writer, to_conv);
 }
 
-int inline convert_float_dec_exp(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_float_dec_exp(Writer *writer,
+                                      const FormatSection &to_conv) {
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;
     fputil::FPBits<long double> float_bits(float_raw);
     if (!float_bits.is_inf_or_nan()) {
       return convert_float_dec_exp_typed<long double>(writer, to_conv,
                                                       float_bits);
     }
   } else {

libc/src/stdio/printf_core/float_hex_converter.h

 //===-- Hexadecimal 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_FLOAT_HEX_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_HEX_CONVERTER_H
 
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.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/float_inf_nan_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 using MantissaInt = fputil::FPBits<long double>::UIntType;
 
-int inline convert_float_hex_exp(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_float_hex_exp(Writer *writer,
+                                      const FormatSection &to_conv) {
   // All of the letters will be defined relative to variable a, which will be
   // the appropriate case based on the name of the conversion.
   // Since the name of the conversion is also 'a', we can just use it directly.
   const char a = to_conv.conv_name;
 
   bool is_negative;
   int exponent;
   MantissaInt mantissa;

libc/src/stdio/printf_core/float_inf_nan_converter.h

 //===-- Inf or Nan 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_FLOAT_INF_NAN_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_FLOAT_INF_NAN_CONVERTER_H
 
 #include "src/__support/FPUtil/FPBits.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 <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 using MantissaInt = fputil::FPBits<long double>::UIntType;
 
-int inline convert_inf_nan(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_inf_nan(Writer *writer, const FormatSection &to_conv) {
   // All of the letters will be defined relative to variable a, which will be
   // the appropriate case based on the case of the conversion.
   const char a = (to_conv.conv_name & 32) | 'A';
 
   bool is_negative;
   MantissaInt mantissa;
   if (to_conv.length_modifier == LengthModifier::L) {
     fputil::FPBits<long double>::UIntType float_raw = to_conv.conv_val_raw;

libc/src/stdio/printf_core/int_converter.h

 //===-- Integer 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_INT_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_INT_CONVERTER_H
 
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
+#include "src/__support/common.h"
 #include "src/__support/integer_to_string.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 <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 // These functions only work on characters that are already known to be in the
 // alphabet. Their behavior is undefined otherwise.
-constexpr char inline to_lower(char a) { return a | 32; }
-constexpr bool inline is_lower(char a) { return (a & 32) > 0; }
+LIBC_INLINE constexpr char to_lower(char a) { return a | 32; }
+LIBC_INLINE constexpr bool is_lower(char a) { return (a & 32) > 0; }
 
-cpp::optional<cpp::string_view> inline num_to_strview(uintmax_t num,
-                                                      cpp::span<char> bufref,
-                                                      char conv_name) {
+LIBC_INLINE cpp::optional<cpp::string_view>
+num_to_strview(uintmax_t num, cpp::span<char> bufref, char conv_name) {
   if (to_lower(conv_name) == 'x') {
     return IntegerToString::hex(num, bufref, is_lower(conv_name));
   } else if (conv_name == 'o') {
     return IntegerToString::oct(num, bufref);
   } else {
     return IntegerToString::dec(num, bufref);
   }
 }
 
-int inline convert_int(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_int(Writer *writer, const FormatSection &to_conv) {
   static constexpr size_t BITS_IN_BYTE = 8;
   static constexpr size_t BITS_IN_NUM = sizeof(uintmax_t) * BITS_IN_BYTE;
 
   uintmax_t num = to_conv.conv_val_raw;
   bool is_negative = false;
   FormatFlags flags = to_conv.flags;
 
   const char a = is_lower(to_conv.conv_name) ? 'a' : 'A';

libc/src/stdio/printf_core/ptr_converter.h

 //===-- Pointer 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_PTR_CONVERTER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PTR_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/int_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
-int inline convert_pointer(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_pointer(Writer *writer, const FormatSection &to_conv) {
   if (to_conv.conv_val_ptr == (void *)(nullptr)) {
     RET_IF_RESULT_NEGATIVE(writer->write("(nullptr)"));
   } else {
     FormatSection hex_conv;
     hex_conv.has_conv = true;
     hex_conv.conv_name = 'x';
     hex_conv.flags = FormatFlags::ALTERNATE_FORM;
     hex_conv.conv_val_raw = reinterpret_cast<uintptr_t>(to_conv.conv_val_ptr);

libc/src/sys/stat/linux/CMakeLists.txt

 add_header_library(
   kernel_statx
   HDRS
     kernel_statx.h
   DEPENDS
     libc.include.sys_stat
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
+    libc.src.__support.common
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   stat
   SRCS
     stat.cpp
   HDRS

libc/src/sys/stat/linux/kernel_statx.h

 //===-- Wrapper over SYS_statx syscall ------------------------------------===//
 //
 // 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_SYS_STAT_LINUX_STATX_H
 #define LLVM_LIBC_SRC_SYS_STAT_LINUX_STATX_H
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
 
 #include <errno.h>
 #include <stdint.h>
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 // It is safe to include this kernel header as it is designed to be
 // included from user programs without causing any name pollution.

 // mask argument to the statx syscall, all fields except the
 // stx_btime field will be filled in.
 constexpr unsigned int STATX_BASIC_STATS_MASK = 0x7FF;
 
 } // Anonymous namespace
 
 namespace __llvm_libc {
 
-inline int statx(int dirfd, const char *__restrict path, int flags,
+LIBC_INLINE int statx(int dirfd, const char *__restrict path, int flags,
                       struct stat *__restrict statbuf) {
   // We make a statx syscall and copy out the result into the |statbuf|.
   ::statx_buf xbuf;
   long ret = __llvm_libc::syscall_impl(SYS_statx, dirfd, path, flags,
                                        ::STATX_BASIC_STATS_MASK, &xbuf);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }

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

deps = [
         "__support_cpp_type_traits",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_cpp_string_view",
     hdrs = ["src/__support/CPP/string_view.h"],
-    deps = [":libc_root"],
+    deps = [
+        ":__support_common",
+        ":libc_root",
+    ],
 )
 
 libc_support_library(
     name = "__support_cpp_type_traits",
     hdrs = ["src/__support/CPP/type_traits.h"],
     deps = [":libc_root"],
 )
 
deps = [
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_normal_float",
     hdrs = ["src/__support/FPUtil/NormalFloat.h"],
     deps = [
+        ":__support_common",
         ":__support_cpp_type_traits",
         ":__support_fputil_fp_bits",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_platform_defs",