[libc] Clean up required LIBC_INLINE uses in src/string

[mcgrathr]

Summary

This was generated using clang-tidy and clang-apply-replacements,
on src/string/*.cpp for just the llvmlibc-inline-function-decl
check, after applying https://reviews.llvm.org/D157164, and then
some manual fixup.

[mcgrathr]

Add some missing annoations that the linter missed.

libc/src/__support/CPP/array.h

 //===-- A self contained equivalent of std::array ---------------*- 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_ARRAY_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_ARRAY_H
 
+#include "src/__support/macros/attributes.h"
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <class T, size_t N> struct array {
   static_assert(N != 0, "Cannot create a __llvm_libc::cpp::array of size 0.");
 
   T Data[N];
   using value_type = T;
   using iterator = T *;
   using const_iterator = const T *;
 
-  constexpr T *data() { return Data; }
-  constexpr const T *data() const { return Data; }
+  LIBC_INLINE constexpr T *data() { return Data; }
+  LIBC_INLINE constexpr const T *data() const { return Data; }
 
-  constexpr T &front() { return Data[0]; }
-  constexpr T &front() const { return Data[0]; }
+  LIBC_INLINE constexpr T &front() { return Data[0]; }
+  LIBC_INLINE constexpr T &front() const { return Data[0]; }
 
-  constexpr T &back() { return Data[N - 1]; }
-  constexpr T &back() const { return Data[N - 1]; }
+  LIBC_INLINE constexpr T &back() { return Data[N - 1]; }
+  LIBC_INLINE constexpr T &back() const { return Data[N - 1]; }
 
-  constexpr T &operator[](size_t Index) { return Data[Index]; }
+  LIBC_INLINE constexpr T &operator[](size_t Index) { return Data[Index]; }
 
-  constexpr const T &operator[](size_t Index) const { return Data[Index]; }
+  LIBC_INLINE constexpr const T &operator[](size_t Index) const {
+    return Data[Index];
+  }
 
-  constexpr size_t size() const { return N; }
+  LIBC_INLINE constexpr size_t size() const { return N; }
 
-  constexpr bool empty() const { return N == 0; }
+  LIBC_INLINE constexpr bool empty() const { return N == 0; }
 
-  constexpr iterator begin() { return Data; }
-  constexpr const_iterator begin() const { return Data; }
+  LIBC_INLINE constexpr iterator begin() { return Data; }
+  LIBC_INLINE constexpr const_iterator begin() const { return Data; }
 
-  constexpr iterator end() { return Data + N; }
-  const_iterator end() const { return Data + N; }
+  LIBC_INLINE constexpr iterator end() { return Data + N; }
+  LIBC_INLINE const_iterator end() const { return Data + N; }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_ARRAY_H

libc/src/__support/CPP/bit.h

 //===-- Freestanding version of bit_cast  -----------------------*- 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_SUPPORT_CPP_BIT_H
 #define LLVM_LIBC_SUPPORT_CPP_BIT_H
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/macros/attributes.h"
 #include "src/__support/macros/config.h" // LIBC_HAS_BUILTIN
 
 namespace __llvm_libc::cpp {
 
 #if LIBC_HAS_BUILTIN(__builtin_bit_cast)
 #define LLVM_LIBC_HAS_BUILTIN_BIT_CAST
 #endif
 
 #if LIBC_HAS_BUILTIN(__builtin_memcpy_inline)
 #define LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
 #endif
 
 // This function guarantees the bitcast to be optimized away by the compiler for
 // GCC >= 8 and Clang >= 6.
-template <class To, class From> constexpr To bit_cast(const From &from) {
+template <class To, class From>
+LIBC_INLINE constexpr To bit_cast(const From &from) {
   static_assert(sizeof(To) == sizeof(From), "To and From must be of same size");
   static_assert(cpp::is_trivially_copyable<To>::value &&
                     cpp::is_trivially_copyable<From>::value,
                 "Cannot bit-cast instances of non-trivially copyable classes.");
 #if defined(LLVM_LIBC_HAS_BUILTIN_BIT_CAST)
   return __builtin_bit_cast(To, from);
 #else
   static_assert(cpp::is_trivially_constructible<To>::value,

libc/src/__support/CPP/bitset.h

 //===-- A self contained equivalent of std::bitset --------------*- 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_BITSET_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H
 
+#include "src/__support/macros/attributes.h"
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc::cpp {
 
 template <size_t NumberOfBits> struct bitset {
   static_assert(NumberOfBits != 0,
                 "Cannot create a __llvm_libc::cpp::bitset of size 0.");
 
-  constexpr void set(size_t Index) {
+  LIBC_INLINE constexpr void set(size_t Index) {
     Data[Index / BITS_PER_UNIT] |= mask(Index);
   }
 
-  constexpr void reset() {
+  LIBC_INLINE constexpr void reset() {
     for (size_t i = 0; i < NUMBER_OF_UNITS; ++i)
       Data[i] = 0;
   }
 
-  constexpr bool test(size_t Index) const {
+  LIBC_INLINE constexpr bool test(size_t Index) const {
     return Data[Index / BITS_PER_UNIT] & mask(Index);
   }
 
-  constexpr void flip() {
+  LIBC_INLINE constexpr void flip() {
     for (size_t i = 0; i < NUMBER_OF_UNITS; ++i)
       Data[i] = ~Data[i];
   }
 
   // This function sets all bits in the range from Start to End (inclusive) to
   // true. It assumes that Start <= End.
-  constexpr void set_range(size_t Start, size_t End) {
+  LIBC_INLINE constexpr void set_range(size_t Start, size_t End) {
     size_t start_index = Start / BITS_PER_UNIT;
     size_t end_index = End / BITS_PER_UNIT;
 
     if (start_index == end_index) {
       // The reason the left shift is split into two parts (instead of just left
       // shifting by End - Start + 1) is because when a number is shifted left
       // by 64 then it wraps around to doing nothing, but shifting by 63 and the
       // shifting by 1 correctly shifts away all of the bits.
if (start_index == end_index) {
 
       // Same as above, by splitting the shift the behavior is more consistent.
       size_t high_bit_mask =
           ((size_t(1) << (End - (end_index * BITS_PER_UNIT))) << 1) - 1;
       Data[end_index] |= high_bit_mask;
     }
   }
 
-  constexpr bool operator==(const bitset<NumberOfBits> &other) {
+  LIBC_INLINE constexpr bool operator==(const bitset<NumberOfBits> &other) {
     for (size_t i = 0; i < NUMBER_OF_UNITS; ++i) {
       if (Data[i] != other.Data[i])
         return false;
     }
     return true;
   }
 
 private:
   static constexpr size_t BITS_PER_BYTE = 8;
   static constexpr size_t BITS_PER_UNIT = BITS_PER_BYTE * sizeof(size_t);
   static constexpr size_t NUMBER_OF_UNITS =
       (NumberOfBits + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
 
-  static constexpr size_t mask(size_t Index) {
+  LIBC_INLINE static constexpr size_t mask(size_t Index) {
     return size_t{1} << (Index % BITS_PER_UNIT);
   }
   size_t Data[NUMBER_OF_UNITS] = {0};
 };
 
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_BITSET_H

libc/src/__support/CPP/cstddef.h

 //===-- A self contained equivalent of cstddef ------------------*- 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_BYTE_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_BYTE_H
 
+#include "src/__support/macros/attributes.h"
 #include "type_traits.h" // For enable_if_t, is_integral_v.
 
 namespace __llvm_libc::cpp {
 
 enum class byte : unsigned char {};
 
 template <class IntegerType>
-constexpr enable_if_t<is_integral_v<IntegerType>, byte>
+LIBC_INLINE constexpr enable_if_t<is_integral_v<IntegerType>, byte>
 operator>>(byte b, IntegerType shift) noexcept {
   return static_cast<byte>(static_cast<unsigned char>(b) >> shift);
 }
 template <class IntegerType>
-constexpr enable_if_t<is_integral_v<IntegerType>, byte &>
+LIBC_INLINE constexpr enable_if_t<is_integral_v<IntegerType>, byte &>
 operator>>=(byte &b, IntegerType shift) noexcept {
   return b = b >> shift;
 }
 template <class IntegerType>
-constexpr enable_if_t<is_integral_v<IntegerType>, byte>
+LIBC_INLINE constexpr enable_if_t<is_integral_v<IntegerType>, byte>
 operator<<(byte b, IntegerType shift) noexcept {
   return static_cast<byte>(static_cast<unsigned char>(b) << shift);
 }
 template <class IntegerType>
-constexpr enable_if_t<is_integral_v<IntegerType>, byte &>
+LIBC_INLINE constexpr enable_if_t<is_integral_v<IntegerType>, byte &>
 operator<<=(byte &b, IntegerType shift) noexcept {
   return b = b << shift;
 }
-constexpr byte operator|(byte l, byte r) noexcept {
+LIBC_INLINE constexpr byte operator|(byte l, byte r) noexcept {
   return static_cast<byte>(static_cast<unsigned char>(l) |
                            static_cast<unsigned char>(r));
 }
-constexpr byte &operator|=(byte &l, byte r) noexcept { return l = l | r; }
-constexpr byte operator&(byte l, byte r) noexcept {
+LIBC_INLINE constexpr byte &operator|=(byte &l, byte r) noexcept {
+  return l = l | r;
+}
+LIBC_INLINE constexpr byte operator&(byte l, byte r) noexcept {
   return static_cast<byte>(static_cast<unsigned char>(l) &
                            static_cast<unsigned char>(r));
 }
-constexpr byte &operator&=(byte &l, byte r) noexcept { return l = l & r; }
-constexpr byte operator^(byte l, byte r) noexcept {
+LIBC_INLINE constexpr byte &operator&=(byte &l, byte r) noexcept {
+  return l = l & r;
+}
+LIBC_INLINE constexpr byte operator^(byte l, byte r) noexcept {
   return static_cast<byte>(static_cast<unsigned char>(l) ^
                            static_cast<unsigned char>(r));
 }
-constexpr byte &operator^=(byte &l, byte r) noexcept { return l = l ^ r; }
-constexpr byte operator~(byte b) noexcept {
+LIBC_INLINE constexpr byte &operator^=(byte &l, byte r) noexcept {
+  return l = l ^ r;
+}
+LIBC_INLINE constexpr byte operator~(byte b) noexcept {
   return static_cast<byte>(~static_cast<unsigned char>(b));
 }
 template <typename IntegerType>
-constexpr enable_if_t<is_integral_v<IntegerType>, IntegerType>
+LIBC_INLINE constexpr enable_if_t<is_integral_v<IntegerType>, IntegerType>
 to_integer(byte b) noexcept {
   return static_cast<IntegerType>(b);
 }
 
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_BYTE_H

libc/src/__support/CPP/new.h

 enum class align_val_t : size_t {};
 
 } // namespace std
 
 namespace __llvm_libc {
 
 class AllocChecker {
   bool success = false;
-  AllocChecker &operator=(bool status) {
+
+  LIBC_INLINE AllocChecker &operator=(bool status) {
     success = status;
     return *this;
   }
 
 public:
-  AllocChecker() = default;
-  operator bool() const { return success; }
+  LIBC_INLINE AllocChecker() = default;
+
+  LIBC_INLINE operator bool() const { return success; }
 
   LIBC_INLINE static void *alloc(size_t s, AllocChecker &ac) {
     void *mem = ::malloc(s);
     ac = (mem != nullptr);
     return mem;
   }
 
   LIBC_INLINE static void *aligned_alloc(size_t s, std::align_val_t align,

libc/src/__support/CPP/optional.h

 #include "src/__support/CPP/utility.h"
 #include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc {
 namespace cpp {
 
 // Trivial in_place_t struct.
 struct in_place_t {
-  LIBC_INLINE_VAR explicit in_place_t() = default;
+  LIBC_INLINE constexpr explicit in_place_t() = default;
 };
 
 // Trivial nullopt_t struct.
 struct nullopt_t {
-  LIBC_INLINE_VAR explicit nullopt_t() = default;
+  LIBC_INLINE constexpr explicit nullopt_t() = default;
 };
 
 // nullopt that can be used and returned.
 LIBC_INLINE_VAR constexpr nullopt_t nullopt{};
 
 // in_place that can be used in the constructor.
 LIBC_INLINE_VAR constexpr in_place_t in_place{};
 

libc/src/__support/CPP/span.h

public:
   using size_type = size_t;
   using difference_type = ptrdiff_t;
   using pointer = T *;
   using const_pointer = const T *;
   using reference = T &;
   using const_reference = const T &;
   using iterator = T *;
 
-  static constexpr size_type dynamic_extent = -1;
+  LIBC_INLINE_VAR static constexpr size_type dynamic_extent = -1;
 
   LIBC_INLINE constexpr span() : span_data(nullptr), span_size(0) {}
 
   LIBC_INLINE constexpr span(pointer first, size_type count)
       : span_data(first), span_size(count) {}
 
   LIBC_INLINE constexpr span(pointer first, pointer end)
       : span_data(first), span_size(end - first) {}

libc/src/__support/CPP/string_view.h

 // 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; }
+  LIBC_INLINE static size_t min(size_t A, size_t B) { return A <= B ? A : B; }
 
   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;
   }

libc/src/__support/CPP/type_traits.h

 template <typename T> struct add_rvalue_reference : type_identity<T &&> {};
 
 template <typename T> struct remove_cvref {
   using type = remove_cv_t<remove_reference_t<T>>;
 };
 template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
 
 namespace details {
-template <typename T, typename... Args> constexpr bool is_unqualified_any_of() {
+template <typename T, typename... Args>
+LIBC_INLINE constexpr bool is_unqualified_any_of() {
   return (... || is_same_v<remove_cv_t<T>, Args>);
 }
 } // namespace details
 
 template <typename T> struct is_integral {
   LIBC_INLINE_VAR static constexpr bool value = details::is_unqualified_any_of<
       T,
 #ifdef __SIZEOF_INT128__

libc/src/__support/common.h

 #endif
 
 // This extra layer of macro allows `name` to be a macro to rename a function.
 #define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
   LLVM_LIBC_FUNCTION_IMPL(type, name, arglist)
 
 namespace __llvm_libc {
 namespace internal {
-constexpr bool same_string(char const *lhs, char const *rhs) {
+LIBC_INLINE constexpr bool same_string(char const *lhs, char const *rhs) {
   for (; *lhs || *rhs; ++lhs, ++rhs)
     if (*lhs != *rhs)
       return false;
   return true;
 }
 } // namespace internal
 } // namespace __llvm_libc
 

libc/src/__support/ctype_utils.h

 //===-- Collection of utils for implementing ctype functions-------*-C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H
 #define LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H
 
+#include "src/__support/macros/attributes.h"
+
 namespace __llvm_libc {
 namespace internal {
 
 // ------------------------------------------------------
 // Rationale: Since these classification functions are
 // called in other functions, we will avoid the overhead
 // of a function call by inlining them.
 // ------------------------------------------------------
 
-static constexpr bool isalpha(unsigned ch) { return (ch | 32) - 'a' < 26; }
+LIBC_INLINE static constexpr bool isalpha(unsigned ch) {
+  return (ch | 32) - 'a' < 26;
+}
 
-static constexpr bool isdigit(unsigned ch) { return (ch - '0') < 10; }
+LIBC_INLINE static constexpr bool isdigit(unsigned ch) {
+  return (ch - '0') < 10;
+}
 
-static constexpr bool isalnum(unsigned ch) {
+LIBC_INLINE static constexpr bool isalnum(unsigned ch) {
   return isalpha(ch) || isdigit(ch);
 }
 
-static constexpr bool isgraph(unsigned ch) { return 0x20 < ch && ch < 0x7f; }
+LIBC_INLINE static constexpr bool isgraph(unsigned ch) {
+  return 0x20 < ch && ch < 0x7f;
+}
 
-static constexpr bool islower(unsigned ch) { return (ch - 'a') < 26; }
+LIBC_INLINE static constexpr bool islower(unsigned ch) {
+  return (ch - 'a') < 26;
+}
 
-static constexpr bool isupper(unsigned ch) { return (ch - 'A') < 26; }
+LIBC_INLINE static constexpr bool isupper(unsigned ch) {
+  return (ch - 'A') < 26;
+}
 
-static constexpr bool isspace(unsigned ch) {
+LIBC_INLINE static constexpr bool isspace(unsigned ch) {
   return ch == ' ' || (ch - '\t') < 5;
 }
 
-static constexpr int tolower(int ch) {
+LIBC_INLINE static constexpr int tolower(int ch) {
   if (isupper(ch))
     return ch + ('a' - 'A');
   return ch;
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif //  LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H

libc/src/string/memory_utils/inline_memmem.h

 //===-- memmem implementation -----------------------------------*- 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_STRING_MEMORY_UTILS_INLINE_MEMMEM_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMEM_H
 
+#include "src/__support/macros/attributes.h"
+
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-constexpr static void *inline_memmem(const void *haystack, size_t haystack_len,
-                                     const void *needle, size_t needle_len,
-                                     Comp &&comp) {
+LIBC_INLINE constexpr static void *
+inline_memmem(const void *haystack, size_t haystack_len, const void *needle,
+              size_t needle_len, Comp &&comp) {
   // TODO: simple brute force implementation. This can be
   // improved upon using well known string matching algorithms.
   if (!needle_len)
     return const_cast<void *>(haystack);
 
   if (needle_len > haystack_len)
     return nullptr;
 

libc/src/string/memory_utils/utils.h

 // Returns the number of bytes to add to ptr to get to the next multiple of
 // alignment. If ptr is already aligned returns alignment.
 template <size_t alignment>
 LIBC_INLINE uintptr_t distance_to_next_aligned(const void *ptr) {
   return alignment - distance_to_align_down<alignment>(ptr);
 }
 
 // Returns the same pointer but notifies the compiler that it is aligned.
-template <size_t alignment, typename T>
-LIBC_INLINE T *assume_aligned(T *ptr) {
+template <size_t alignment, typename T> LIBC_INLINE T *assume_aligned(T *ptr) {
   return reinterpret_cast<T *>(__builtin_assume_aligned(ptr, alignment));
 }
 
 // Returns true iff memory regions [p1, p1 + size] and [p2, p2 + size] are
 // disjoint.
 LIBC_INLINE bool is_disjoint(const void *p1, const void *p2, size_t size) {
   const char *a = static_cast<const char *>(p1);
   const char *b = static_cast<const char *>(p2);

 
 // Performs a constant count copy.
 template <size_t Size>
 LIBC_INLINE void memcpy_inline(void *__restrict dst,
                                const void *__restrict src) {
 #ifdef LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
   __builtin_memcpy_inline(dst, src, Size);
 #else
   // In memory functions `memcpy_inline` is instantiated several times with
   // different value of the Size parameter. This doesn't play well with GCC's
-// Value Range Analysis that wrongly detects out of bounds accesses. We disable
-// the 'array-bounds' warning for the purpose of this function.
+  // Value Range Analysis that wrongly detects out of bounds accesses. We
+  // disable the 'array-bounds' warning for the purpose of this function.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Warray-bounds"
   for (size_t i = 0; i < Size; ++i)
     static_cast<char *>(dst)[i] = static_cast<const char *>(src)[i];
 #pragma GCC diagnostic pop
 #endif
 }
 
 using Ptr = cpp::byte *;        // Pointer to raw data.
 using CPtr = const cpp::byte *; // Const pointer to raw data.
 
 // This type makes sure that we don't accidentally promote an integral type to
 // another one. It is only constructible from the exact T type.
 template <typename T> struct StrictIntegralType {
   static_assert(cpp::is_integral_v<T>);
 
   // Can only be constructed from a T.
   template <typename U, cpp::enable_if_t<cpp::is_same_v<U, T>, bool> = 0>
-  StrictIntegralType(U value) : value(value) {}
+  LIBC_INLINE StrictIntegralType(U value) : value(value) {}
 
   // Allows using the type in an if statement.
-  explicit operator bool() const { return value; }
+  LIBC_INLINE explicit operator bool() const { return value; }
 
   // If type is unsigned (bcmp) we allow bitwise OR operations.
-  StrictIntegralType operator|(const StrictIntegralType &Rhs) const {
+  LIBC_INLINE StrictIntegralType
+  operator|(const StrictIntegralType &Rhs) const {
     static_assert(!cpp::is_signed_v<T>);
     return value | Rhs.value;
   }
 
   // For interation with the C API we allow explicit conversion back to the
   // `int` type.
-  explicit operator int() const {
+  LIBC_INLINE explicit operator int() const {
     // bit_cast makes sure that T and int have the same size.
     return cpp::bit_cast<int>(value);
   }
 
   // Helper to get the zero value.
   LIBC_INLINE static constexpr StrictIntegralType ZERO() { return {T(0)}; }
   LIBC_INLINE static constexpr StrictIntegralType NONZERO() { return {T(1)}; }
 

 // aligned accesses and recombine them through shifts and logicals operations.
 // For instance, if we know that the pointer is 2-byte aligned we can decompose
 // a 64-bit operation into four 16-bit operations.
 
 // Loads a 'ValueType' by decomposing it into several loads that are assumed to
 // be aligned.
 // e.g. load_aligned<uint32_t, uint16_t, uint16_t>(ptr);
 template <typename ValueType, typename T, typename... TS>
-ValueType load_aligned(CPtr src) {
+LIBC_INLINE ValueType load_aligned(CPtr src) {
   static_assert(sizeof(ValueType) >= (sizeof(T) + ... + sizeof(TS)));
   const ValueType value = load<T>(assume_aligned<sizeof(T)>(src));
   if constexpr (sizeof...(TS) > 0) {
     constexpr size_t shift = sizeof(T) * 8;
     const ValueType next = load_aligned<ValueType, TS...>(src + sizeof(T));
     if constexpr (Endian::IS_LITTLE)
       return value | (next << shift);
     else if constexpr (Endian::IS_BIG)
       return (value << shift) | next;
     else
       deferred_static_assert("Invalid endianness");
   } else {
     return value;
   }
 }
 
 // Alias for loading a 'uint32_t'.
 template <typename T, typename... TS>
-auto load32_aligned(CPtr src, size_t offset) {
+LIBC_INLINE auto load32_aligned(CPtr src, size_t offset) {
   static_assert((sizeof(T) + ... + sizeof(TS)) == sizeof(uint32_t));
   return load_aligned<uint32_t, T, TS...>(src + offset);
 }
 
 // Alias for loading a 'uint64_t'.
 template <typename T, typename... TS>
-auto load64_aligned(CPtr src, size_t offset) {
+LIBC_INLINE auto load64_aligned(CPtr src, size_t offset) {
   static_assert((sizeof(T) + ... + sizeof(TS)) == sizeof(uint64_t));
   return load_aligned<uint64_t, T, TS...>(src + offset);
 }
 
 // Stores a 'ValueType' by decomposing it into several stores that are assumed
 // to be aligned.
 // e.g. store_aligned<uint32_t, uint16_t, uint16_t>(value, ptr);
 template <typename ValueType, typename T, typename... TS>
-void store_aligned(ValueType value, Ptr dst) {
+LIBC_INLINE void store_aligned(ValueType value, Ptr dst) {
   static_assert(sizeof(ValueType) >= (sizeof(T) + ... + sizeof(TS)));
   constexpr size_t shift = sizeof(T) * 8;
   if constexpr (Endian::IS_LITTLE) {
     store<T>(assume_aligned<sizeof(T)>(dst), value & ~T(0));
     if constexpr (sizeof...(TS) > 0)
       store_aligned<ValueType, TS...>(value >> shift, dst + sizeof(T));
   } else if constexpr (Endian::IS_BIG) {
     constexpr size_t OFFSET = (0 + ... + sizeof(TS));
     store<T>(assume_aligned<sizeof(T)>(dst + OFFSET), value & ~T(0));
     if constexpr (sizeof...(TS) > 0)
       store_aligned<ValueType, TS...>(value >> shift, dst);
   } else {
     deferred_static_assert("Invalid endianness");
   }
 }
 
 // Alias for storing a 'uint32_t'.
 template <typename T, typename... TS>
-void store32_aligned(uint32_t value, Ptr dst, size_t offset) {
+LIBC_INLINE void store32_aligned(uint32_t value, Ptr dst, size_t offset) {
   static_assert((sizeof(T) + ... + sizeof(TS)) == sizeof(uint32_t));
   store_aligned<uint32_t, T, TS...>(value, dst + offset);
 }
 
 // Alias for storing a 'uint64_t'.
 template <typename T, typename... TS>
-void store64_aligned(uint64_t value, Ptr dst, size_t offset) {
+LIBC_INLINE void store64_aligned(uint64_t value, Ptr dst, size_t offset) {
   static_assert((sizeof(T) + ... + sizeof(TS)) == sizeof(uint64_t));
   store_aligned<uint64_t, T, TS...>(value, dst + offset);
 }
 
 // Advances the pointers p1 and p2 by offset bytes and decrease count by the
 // same amount.
 template <typename T1, typename T2>
 LIBC_INLINE void adjust(ptrdiff_t offset, T1 *__restrict &p1,

 void align_p1_to_next_boundary(T1 *__restrict &p1, T2 *__restrict &p2,
                                size_t &count) {
   adjust(distance_to_next_aligned<SIZE>(p1), p1, p2, count);
   p1 = assume_aligned<SIZE>(p1);
 }
 
 // Same as align_p1_to_next_boundary above but with a single pointer instead.
 template <size_t SIZE, typename T1>
-void align_to_next_boundary(T1 *&p1, size_t &count) {
+LIBC_INLINE void align_to_next_boundary(T1 *&p1, size_t &count) {
   CPtr dummy;
   align_p1_to_next_boundary<SIZE>(p1, dummy, count);
 }
 
 // An enum class that discriminates between the first and second pointer.
 enum class Arg { P1, P2, Dst = P1, Src = P2 };
 
 // Same as align_p1_to_next_boundary but allows for aligning p2 instead of p1.
 // Precondition: &p1 != &p2
 template <size_t SIZE, Arg AlignOn, typename T1, typename T2>
-void align_to_next_boundary(T1 *__restrict &p1, T2 *__restrict &p2,
+LIBC_INLINE void align_to_next_boundary(T1 *__restrict &p1, T2 *__restrict &p2,
                                         size_t &count) {
   if constexpr (AlignOn == Arg::P1)
     align_p1_to_next_boundary<SIZE>(p1, p2, count);
   else if constexpr (AlignOn == Arg::P2)
     align_p1_to_next_boundary<SIZE>(p2, p1, count); // swapping p1 and p2.
   else
     deferred_static_assert("AlignOn must be either Arg::P1 or Arg::P2");
 }
 
 template <size_t SIZE> struct AlignHelper {
-  AlignHelper(CPtr ptr) : offset_(distance_to_next_aligned<SIZE>(ptr)) {}
+  LIBC_INLINE AlignHelper(CPtr ptr)
+      : offset_(distance_to_next_aligned<SIZE>(ptr)) {}
 
   LIBC_INLINE bool not_aligned() const { return offset_ != SIZE; }
   LIBC_INLINE uintptr_t offset() const { return offset_; }
 
 private:
   uintptr_t offset_;
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MEMORY_UTILS_UTILS_H

libc/src/string/string_utils.h

 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/inline_bzero.h"
 #include "src/string/memory_utils/inline_memcpy.h"
 #include <stddef.h> // For size_t
 
 namespace __llvm_libc {
 namespace internal {
 
-template <typename Word> constexpr Word repeat_byte(Word byte) {
+template <typename Word> LIBC_INLINE constexpr Word repeat_byte(Word byte) {
   constexpr size_t BITS_IN_BYTE = 8;
   constexpr size_t BYTE_MASK = 0xff;
   Word result = 0;
   byte = byte & BYTE_MASK;
   for (size_t i = 0; i < sizeof(Word); ++i)
     result = (result << BITS_IN_BYTE) | byte;
   return result;
 }

 // The next transformation is a simple mask. All zero bytes will have the high
 // bit set after the subtraction, so each byte is masked with 0x80. This narrows
 // the set of bytes that result in a non-zero value to only zero bytes and bytes
 // with the high bit and any other bit set.
 // The final transformation masks the result of the previous transformations
 // with the inverse of the original byte. This means that any byte that had the
 // high bit set will no longer have it set, narrowing the list of bytes which
 // result in non-zero values to just the zero byte.
-template <typename Word> constexpr bool has_zeroes(Word block) {
+template <typename Word> LIBC_INLINE constexpr bool has_zeroes(Word block) {
   constexpr Word LOW_BITS = repeat_byte<Word>(0x01);
   constexpr Word HIGH_BITS = repeat_byte<Word>(0x80);
   Word subtracted = block - LOW_BITS;
   Word inverted = ~block;
   return (subtracted & inverted & HIGH_BITS) != 0;
 }
 
 template <typename Word>