[libc] Fix more inline definitions

[mcgrathr]

Summary

Fix a bunch more instances of incorrect use of the static
keyword and missing use of LIBC_INLINE and LIBC_INLINE_VAR
macros. Note that even forward declarations and generic template
declarations must follow the prescribed patterns for libc code so
that they match every definition, all template specializations.

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 explicit in_place_t() = default;
+  LIBC_INLINE_VAR explicit in_place_t() = default;
 };
 
 // Trivial nullopt_t struct.
 struct nullopt_t {
-  LIBC_INLINE explicit nullopt_t() = default;
+  LIBC_INLINE_VAR explicit nullopt_t() = default;
 };
 
 // nullopt that can be used and returned.
-inline constexpr nullopt_t nullopt{};
+LIBC_INLINE_VAR constexpr nullopt_t nullopt{};
 
 // in_place that can be used in the constructor.
-inline constexpr in_place_t in_place{};
+LIBC_INLINE_VAR constexpr in_place_t in_place{};
 
 // This is very simple implementation of the std::optional class. It makes
 // several assumptions that the underlying type is trivially constructable,
 // copyable, or movable.
 template <typename T> class optional {
   template <typename U> class OptionalStorage {
     union {
       char empty;

libc/src/__support/CPP/span.h

 //===-- Standalone implementation std::span ---------------------*- 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_SPAN_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_SPAN_H
 
 #include <stddef.h> // For size_t
 
 #include "array.h"       // For array
 #include "type_traits.h" // For remove_cv_t, enable_if_t, is_same_v, is_const_v
 
+#include "src/__support/macros/attributes.h"
+
 namespace __llvm_libc::cpp {
 
 // A trimmed down implementation of std::span.
 // Missing features:
 // - No constant size spans (e.g. Span<int, 4>),
 // - Only handle pointer like types, no fancy interators nor object overriding
 //   the & operator,
 // - No implicit type conversion (e.g. Span<B>, initialized with As where A
 //   inherits from B),
 // - No reverse iterators
 template <typename T> class span {
   template <typename U>
-  inline static constexpr bool is_const_view_v =
+  LIBC_INLINE_VAR static constexpr bool is_const_view_v =
       !cpp::is_const_v<U> && cpp::is_const_v<T> &&
       cpp::is_same_v<U, remove_cv_t<T>>;
 
   template <typename U>
-  inline static constexpr bool is_compatible_v =
+  LIBC_INLINE_VAR static constexpr bool is_compatible_v =
       cpp::is_same_v<U, T> || is_const_view_v<U>;
 
 public:
   using element_type = T;
   using value_type = remove_cv_t<T>;
   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;
 
-  constexpr span() : span_data(nullptr), span_size(0) {}
+  LIBC_INLINE constexpr span() : span_data(nullptr), span_size(0) {}
 
-  constexpr span(pointer first, size_type count)
+  LIBC_INLINE constexpr span(pointer first, size_type count)
       : span_data(first), span_size(count) {}
 
-  constexpr span(pointer first, pointer end)
+  LIBC_INLINE constexpr span(pointer first, pointer end)
       : span_data(first), span_size(end - first) {}
 
   template <typename U, size_t N,
             cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  constexpr span(U (&arr)[N]) : span_data(arr), span_size(N) {}
+  LIBC_INLINE constexpr span(U (&arr)[N]) : span_data(arr), span_size(N) {}
 
   template <typename U, size_t N,
             cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  constexpr span(array<U, N> &arr)
+  LIBC_INLINE constexpr span(array<U, N> &arr)
       : span_data(arr.data()), span_size(arr.size()) {}
 
   template <typename U, cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  constexpr span(span<U> &s) : span_data(s.data()), span_size(s.size()) {}
+  LIBC_INLINE constexpr span(span<U> &s)
+      : span_data(s.data()), span_size(s.size()) {}
 
   template <typename U, cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  constexpr span &operator=(span<U> &s) {
+  LIBC_INLINE constexpr span &operator=(span<U> &s) {
     span_data = s.data();
     span_size = s.size();
     return *this;
   }
 
-  ~span() = default;
-  constexpr reference operator[](size_type index) const {
+  LIBC_INLINE ~span() = default;
+
+  LIBC_INLINE constexpr reference operator[](size_type index) const {
     return data()[index];
   }
-  constexpr iterator begin() const { return data(); }
-  constexpr iterator end() const { return data() + size(); }
-  constexpr reference front() const { return (*this)[0]; }
-  constexpr reference back() const { return (*this)[size() - 1]; }
-  constexpr pointer data() const { return span_data; }
-  constexpr size_type size() const { return span_size; }
-  constexpr size_type size_bytes() const { return sizeof(T) * size(); }
-  constexpr bool empty() const { return size() == 0; }
 
-  constexpr span<element_type> subspan(size_type offset,
-                                       size_type count = dynamic_extent) const {
+  LIBC_INLINE constexpr iterator begin() const { return data(); }
+  LIBC_INLINE constexpr iterator end() const { return data() + size(); }
+  LIBC_INLINE constexpr reference front() const { return (*this)[0]; }
+  LIBC_INLINE constexpr reference back() const { return (*this)[size() - 1]; }
+  LIBC_INLINE constexpr pointer data() const { return span_data; }
+  LIBC_INLINE constexpr size_type size() const { return span_size; }
+  LIBC_INLINE constexpr size_type size_bytes() const {
+    return sizeof(T) * size();
+  }
+  LIBC_INLINE constexpr bool empty() const { return size() == 0; }
+
+  LIBC_INLINE constexpr span<element_type>
+  subspan(size_type offset, size_type count = dynamic_extent) const {
     return span<element_type>(data() + offset, count_to_size(offset, count));
   }
 
-  constexpr span<element_type> first(size_type count) const {
+  LIBC_INLINE constexpr span<element_type> first(size_type count) const {
     return subspan(0, count);
   }
 
-  constexpr span<element_type> last(size_type count) const {
+  LIBC_INLINE constexpr span<element_type> last(size_type count) const {
     return span<element_type>(data() + (size() - count), count);
   }
 
 private:
-  constexpr size_type count_to_size(size_type offset, size_type count) const {
+  LIBC_INLINE constexpr size_type count_to_size(size_type offset,
+                                                size_type count) const {
     if (count == dynamic_extent) {
       return size() - offset;
     }
     return count;
   }
 
   T *span_data;
   size_t span_size;
 };
 
 } // namespace __llvm_libc::cpp
 
 #endif /* LLVM_LIBC_SRC_SUPPORT_CPP_SPAN_H */

libc/src/__support/CPP/string_view.h

public:
   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;
+  LIBC_INLINE_VAR static constexpr size_t npos = -1;
 
   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.
   LIBC_INLINE constexpr string_view(const char *Str)
       : Data(Str), Len(length(Str)) {}

libc/src/__support/CPP/type_traits.h

 //===-- Self contained C++ type traits --------------------------*- 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_TYPETRAITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
+#include "src/__support/macros/attributes.h"
+
 namespace __llvm_libc {
 namespace cpp {
 
 template <typename T> struct type_identity {
   using type = T;
 };
 
 template <bool B, typename T> struct enable_if;
 template <typename T> struct enable_if<true, T> : type_identity<T> {};
 template <bool B, typename T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 
 template <typename T, T v> struct integral_constant {
   using value_type = T;
-  static constexpr T value = v;
+  LIBC_INLINE_VAR static constexpr T value = v;
 };
 using true_type = cpp::integral_constant<bool, true>;
 using false_type = cpp::integral_constant<bool, false>;
 
 template <class T>
 struct is_trivially_copyable
     : public integral_constant<bool, __is_trivially_copyable(T)> {};
 
 template <class T, class... Args>
 struct is_trivially_constructible
     : integral_constant<bool, __is_trivially_constructible(T, Args...)> {};
 
 template <typename T, typename U> struct is_same : cpp::false_type {};
 template <typename T> struct is_same<T, T> : cpp::true_type {};
 template <typename T, typename U>
-inline constexpr bool is_same_v = is_same<T, U>::value;
+LIBC_INLINE_VAR constexpr bool is_same_v = is_same<T, U>::value;
 
 template <class T> struct is_const : cpp::false_type {};
 template <class T> struct is_const<const T> : cpp::true_type {};
-template <class T> inline constexpr bool is_const_v = is_const<T>::value;
+template <class T>
+LIBC_INLINE_VAR constexpr bool is_const_v = is_const<T>::value;
 
 template <typename T> struct remove_cv : type_identity<T> {};
 template <typename T> struct remove_cv<const T> : type_identity<T> {};
 template <typename T> struct remove_cv<volatile T> : type_identity<T> {};
 template <typename T> struct remove_cv<const volatile T> : type_identity<T> {};
 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
 template <typename T> struct remove_reference : type_identity<T> {};

 
 namespace details {
 template <typename T, typename... Args> constexpr bool is_unqualified_any_of() {
   return (... || is_same_v<remove_cv_t<T>, Args>);
 }
 } // namespace details
 
 template <typename T> struct is_integral {
-  static constexpr bool value = details::is_unqualified_any_of<
+  LIBC_INLINE_VAR static constexpr bool value = details::is_unqualified_any_of<
       T,
 #ifdef __SIZEOF_INT128__
       __int128_t, __uint128_t,
 #endif
       char, signed char, unsigned char, short, unsigned short, int,
       unsigned int, long, unsigned long, long long, unsigned long long, bool>();
 };
 template <typename T>
-inline constexpr bool is_integral_v = is_integral<T>::value;
+LIBC_INLINE_VAR constexpr bool is_integral_v = is_integral<T>::value;
 
 template <typename T> struct is_enum {
-  static constexpr bool value = __is_enum(T);
+  LIBC_INLINE_VAR static constexpr bool value = __is_enum(T);
 };
-template <typename T> inline constexpr bool is_enum_v = is_enum<T>::value;
+template <typename T>
+LIBC_INLINE_VAR constexpr bool is_enum_v = is_enum<T>::value;
 
 template <typename T> struct is_pointer : cpp::false_type {};
 template <typename T> struct is_pointer<T *> : cpp::true_type {};
 template <typename T> struct is_pointer<T *const> : cpp::true_type {};
 template <typename T> struct is_pointer<T *volatile> : cpp::true_type {};
 template <typename T> struct is_pointer<T *const volatile> : cpp::true_type {};
-template <typename T> inline constexpr bool is_pointer_v = is_pointer<T>::value;
+template <typename T>
+LIBC_INLINE_VAR constexpr bool is_pointer_v = is_pointer<T>::value;
 
 template <typename T> struct is_floating_point {
-  static constexpr bool value =
+  LIBC_INLINE_VAR static constexpr bool value =
       details::is_unqualified_any_of<T, float, double, long double>();
 };
 template <typename T>
-inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+LIBC_INLINE_VAR constexpr bool is_floating_point_v =
+    is_floating_point<T>::value;
 
 template <typename T> struct is_arithmetic {
-  static constexpr bool value =
+  LIBC_INLINE_VAR static constexpr bool value =
       is_integral<T>::value || is_floating_point<T>::value;
 };
 template <typename T>
-inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+LIBC_INLINE_VAR constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
 
 namespace details {
 template <typename T, bool = is_arithmetic<T>::value>
 struct is_signed : integral_constant<bool, (T(-1) < T(0))> {};
 template <typename T> struct is_signed<T, false> : false_type {};
 
 template <typename T, bool = is_arithmetic<T>::value>
 struct is_unsigned : integral_constant<bool, (T(-1) > T(0))> {};
 template <typename T> struct is_unsigned<T, false> : false_type {};
 } // namespace details
 
 template <typename T> struct is_signed {
-  static constexpr bool value = details::is_signed<T>::value;
-  constexpr operator bool() const { return value; }
-  constexpr bool operator()() const { return value; }
+  LIBC_INLINE_VAR static constexpr bool value = details::is_signed<T>::value;
+  LIBC_INLINE constexpr operator bool() const { return value; }
+  LIBC_INLINE constexpr bool operator()() const { return value; }
 };
-template <typename T> inline constexpr bool is_signed_v = is_signed<T>::value;
+template <typename T>
+LIBC_INLINE_VAR constexpr bool is_signed_v = is_signed<T>::value;
 
 template <typename T> struct is_unsigned {
-  static constexpr bool value = details::is_unsigned<T>::value;
-  constexpr operator bool() const { return value; }
-  constexpr bool operator()() const { return value; }
+  LIBC_INLINE_VAR static constexpr bool value = details::is_unsigned<T>::value;
+  LIBC_INLINE constexpr operator bool() const { return value; }
+  LIBC_INLINE constexpr bool operator()() const { return value; }
 };
 template <typename T>
-inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
+LIBC_INLINE_VAR constexpr bool is_unsigned_v = is_unsigned<T>::value;
 
 template <typename T> struct make_unsigned;
 template <> struct make_unsigned<char> : type_identity<unsigned char> {};
 template <> struct make_unsigned<signed char> : type_identity<unsigned char> {};
 template <> struct make_unsigned<short> : type_identity<unsigned short> {};
 template <> struct make_unsigned<int> : type_identity<unsigned int> {};
 template <> struct make_unsigned<long> : type_identity<unsigned long> {};
 template <>

 struct conditional : type_identity<T> {};
 template <typename T, typename F>
 struct conditional<false, T, F> : type_identity<F> {};
 template <bool B, typename T, typename F>
 using conditional_t = typename conditional<B, T, F>::type;
 
 template <typename T>
 struct is_void : is_same<void, typename remove_cv<T>::type> {};
-template <typename T> inline constexpr bool is_void_v = is_void<T>::value;
+template <typename T>
+LIBC_INLINE_VAR constexpr bool is_void_v = is_void<T>::value;
 template <class T> T declval();
 
 // Compile time checks on implicit conversions.
 namespace details {
 template <typename...> using void_t = void;
 template <typename T> void convertible_to_helper(T);
 } // namespace details
 
 template <typename F, typename T, typename = void>
-inline constexpr bool is_convertible_v = false;
+LIBC_INLINE_VAR constexpr bool is_convertible_v = false;
 
+// FIXME: This should use LIBC_INLINE_VAR, but clang buggily complains about
+// this when LIBC_INLINE_VAR uses [[clang::internal_linkage]].
 template <typename F, typename T>
-inline constexpr bool
+constexpr bool
     is_convertible_v<F, T,
                      details::void_t<decltype(details::convertible_to_helper<T>(
                          declval<F>()))>> = true;
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/StringUtil/tables/linux_extension_signals.h

 
 #include <signal.h> // For signal numbers
 
 namespace __llvm_libc {
 
 // The array being larger than necessary isn't a problem. The MsgMappings will
 // be set to their default state which maps 0 to an empty string. This will get
 // filtered out in the MessageMapper building stage.
-inline constexpr const MsgTable<3> LINUX_SIGNALS = {
+LIBC_INLINE_VAR constexpr const MsgTable<3> LINUX_SIGNALS = {
 #ifdef SIGSTKFLT
     MsgMapping(SIGSTKFLT, "Stack fault"), // unused
 #endif
     MsgMapping(SIGWINCH, "Window changed"),
 #ifdef SIGPWR
     MsgMapping(SIGPWR, "Power failure"), // ignored
 #endif
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_EXTENSION_SIGNALS_H

libc/src/__support/StringUtil/tables/linux_platform_errors.h

 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_PLATFORM_ERRORS_H
 
 #include "linux_extension_errors.h"
 #include "posix_errors.h"
 #include "stdc_errors.h"
 
 namespace __llvm_libc {
 
-inline constexpr auto PLATFORM_ERRORS =
+LIBC_INLINE_VAR constexpr auto PLATFORM_ERRORS =
     STDC_ERRORS + POSIX_ERRORS + LINUX_ERRORS;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_PLATFORM_ERRORS_H

libc/src/__support/StringUtil/tables/linux_platform_signals.h

 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_PLATFORM_SIGNALS_H
 
 #include "linux_extension_signals.h"
 #include "posix_signals.h"
 #include "stdc_signals.h"
 
 namespace __llvm_libc {
 
-inline constexpr auto PLATFORM_SIGNALS =
+LIBC_INLINE_VAR constexpr auto PLATFORM_SIGNALS =
     STDC_SIGNALS + POSIX_SIGNALS + LINUX_SIGNALS;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_PLATFORM_SIGNALS_H

libc/src/__support/StringUtil/tables/minimal_platform_errors.h

 //===-- Map of error numbers to strings for a stdc platform -----*- 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_STRING_UTIL_TABLES_MINIMAL_PLATFORM_ERRORS_H
 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_MINIMAL_PLATFORM_ERRORS_H
 
 #include "stdc_errors.h"
 
 namespace __llvm_libc {
 
-inline constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
+LIBC_INLINE_VAR constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_MINIMAL_PLATFORM_ERRORS_H

libc/src/__support/StringUtil/tables/minimal_platform_signals.h

 //===-- Map of error numbers to strings for a stdc platform -----*- 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_STRING_UTIL_TABLES_MINIMAL_PLATFORM_SIGNALS_H
 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_MINIMAL_PLATFORM_SIGNALS_H
 
 #include "stdc_signals.h"
 
 namespace __llvm_libc {
 
-inline constexpr auto PLATFORM_SIGNALS = STDC_SIGNALS;
+LIBC_INLINE_VAR constexpr auto PLATFORM_SIGNALS = STDC_SIGNALS;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_MINIMAL_PLATFORM_SIGNALS_H

libc/src/__support/StringUtil/tables/posix_errors.h

 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_POSIX_ERRORS_H
 
 #include "src/__support/StringUtil/message_mapper.h"
 
 #include <errno.h> // For error macros
 
 namespace __llvm_libc {
 
-inline constexpr MsgTable<76> POSIX_ERRORS = {
+LIBC_INLINE_VAR constexpr MsgTable<76> POSIX_ERRORS = {
     MsgMapping(EPERM, "Operation not permitted"),
     MsgMapping(ENOENT, "No such file or directory"),
     MsgMapping(ESRCH, "No such process"),
     MsgMapping(EINTR, "Interrupted system call"),
     MsgMapping(EIO, "Input/output error"),
     MsgMapping(ENXIO, "No such device or address"),
     MsgMapping(E2BIG, "Argument list too long"),
     MsgMapping(ENOEXEC, "Exec format error"),

libc/src/__support/StringUtil/tables/posix_signals.h

 
 #include "src/__support/CPP/array.h"
 #include "src/__support/StringUtil/message_mapper.h"
 
 #include <signal.h> // For signal numbers
 
 namespace __llvm_libc {
 
-inline constexpr MsgTable<22> POSIX_SIGNALS = {
+LIBC_INLINE_VAR constexpr MsgTable<22> POSIX_SIGNALS = {
     MsgMapping(SIGHUP, "Hangup"),
     MsgMapping(SIGQUIT, "Quit"),
     MsgMapping(SIGTRAP, "Trace/breakpoint trap"),
     MsgMapping(SIGBUS, "Bus error"),
     MsgMapping(SIGKILL, "Killed"),
     MsgMapping(SIGUSR1, "User defined signal 1"),
     MsgMapping(SIGUSR2, "User defined signal 2"),
     MsgMapping(SIGPIPE, "Broken pipe"),

libc/src/__support/StringUtil/tables/signal_table.h

 #endif
 
 #if USE_LINUX_PLATFORM_SIGNALS
 #include "linux_extension_signals.h"
 #endif
 
 namespace __llvm_libc::internal {
 
-inline constexpr auto PLATFORM_SIGNALS = []() {
+LIBC_INLINE_VAR constexpr auto PLATFORM_SIGNALS = []() {
   if constexpr (USE_LINUX_PLATFORM_SIGNALS) {
     return STDC_SIGNALS + POSIX_SIGNALS + LINUX_SIGNALS;
   } else {
     return STDC_SIGNALS;
   }
 }();
 
 } // namespace __llvm_libc::internal
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_SIGNAL_TABLE_H

libc/src/__support/StringUtil/tables/stdc_errors.h

 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_STDC_ERRORS_H
 
 #include "src/__support/StringUtil/message_mapper.h"
 
 #include <errno.h> // For error macros
 
 namespace __llvm_libc {
 
-inline constexpr const MsgTable<4> STDC_ERRORS = {
+LIBC_INLINE_VAR constexpr const MsgTable<4> STDC_ERRORS = {
     MsgMapping(0, "Success"),
     MsgMapping(EDOM, "Numerical argument out of domain"),
     MsgMapping(ERANGE, "Numerical result out of range"),
     MsgMapping(EILSEQ, "Invalid or incomplete multibyte or wide character"),
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_ERRORS_H

libc/src/__support/StringUtil/tables/stdc_signals.h

 #define LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_STDC_SIGNALS_H
 
 #include <signal.h> // For signal numbers
 
 #include "src/__support/StringUtil/message_mapper.h"
 
 namespace __llvm_libc {
 
-inline constexpr const MsgTable<6> STDC_SIGNALS = {
+LIBC_INLINE_VAR constexpr const MsgTable<6> STDC_SIGNALS = {
     MsgMapping(SIGINT, "Interrupt"),
     MsgMapping(SIGILL, "Illegal instruction"),
     MsgMapping(SIGABRT, "Aborted"),
     MsgMapping(SIGFPE, "Floating point exception"),
     MsgMapping(SIGSEGV, "Segmentation fault"),
     MsgMapping(SIGTERM, "Terminated"),
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_STRING_UTIL_TABLES_LINUX_SIGNALS_H

libc/src/__support/UInt.h

 #include <stdint.h>
 
 namespace __llvm_libc::cpp {
 
 template <size_t Bits, bool Signed> struct BigInt {
 
   static_assert(Bits > 0 && Bits % 64 == 0,
                 "Number of bits in BigInt should be a multiple of 64.");
-  static constexpr size_t WORDCOUNT = Bits / 64;
+  static LIBC_INLINE_VAR constexpr size_t WORDCOUNT = Bits / 64;
   uint64_t val[WORDCOUNT]{};
 
-  static constexpr uint64_t MASK32 = 0xFFFFFFFFu;
+  static LIBC_INLINE_VAR constexpr uint64_t MASK32 = 0xFFFFFFFFu;
 
-  static constexpr uint64_t low(uint64_t v) { return v & MASK32; }
-  static constexpr uint64_t high(uint64_t v) { return (v >> 32) & MASK32; }
+  static LIBC_INLINE constexpr uint64_t low(uint64_t v) { return v & MASK32; }
+  static LIBC_INLINE constexpr uint64_t high(uint64_t v) { return (v >> 32) & MASK32; }
 
-  constexpr BigInt() = default;
+  LIBC_INLINE constexpr BigInt() = default;
 
-  constexpr BigInt(const BigInt<Bits, Signed> &other) = default;
+  LIBC_INLINE constexpr BigInt(const BigInt<Bits, Signed> &other) = default;
 
   template <size_t OtherBits, bool OtherSigned>
-  constexpr BigInt(const BigInt<OtherBits, OtherSigned> &other) {
+  LIBC_INLINE constexpr BigInt(const BigInt<OtherBits, OtherSigned> &other) {
     if (OtherBits >= Bits) {
       for (size_t i = 0; i < WORDCOUNT; ++i)
         val[i] = other[i];
     } else {
       size_t i = 0;
       for (; i < OtherBits / 64; ++i)
         val[i] = other[i];
       uint64_t sign = 0;
       if constexpr (Signed && OtherSigned) {
         sign = static_cast<uint64_t>(
             -static_cast<int64_t>(other[OtherBits / 64 - 1] >> 63));
       }
       for (; i < WORDCOUNT; ++i)
         val[i] = sign;
     }
   }
 
   // Construct a BigInt from a C array.
   template <size_t N, enable_if_t<N <= WORDCOUNT, int> = 0>
-  constexpr BigInt(const uint64_t (&nums)[N]) {
+  LIBC_INLINE constexpr BigInt(const uint64_t (&nums)[N]) {
     size_t min_wordcount = N < WORDCOUNT ? N : WORDCOUNT;
     size_t i = 0;
     for (; i < min_wordcount; ++i)
       val[i] = nums[i];
 
     // If nums doesn't completely fill val, then fill the rest with zeroes.
     for (; i < WORDCOUNT; ++i)
       val[i] = 0;
   }
 
   // Initialize the first word to |v| and the rest to 0.
   template <typename T,
             typename = cpp::enable_if_t<is_integral_v<T> && sizeof(T) <= 16>>
-  constexpr BigInt(T v) {
+  LIBC_INLINE constexpr BigInt(T v) {
     val[0] = static_cast<uint64_t>(v);
 
     if constexpr (Bits == 64)
       return;
 
     // Bits is at least 128.
     size_t i = 1;
     if constexpr (sizeof(T) == 16) {
       val[1] = static_cast<uint64_t>(v >> 64);
       i = 2;
     }
 
     uint64_t sign = (Signed && (v < 0)) ? 0xffff'ffff'ffff'ffff : 0;
     for (; i < WORDCOUNT; ++i) {
       val[i] = sign;
     }
   }
 
-  constexpr explicit BigInt(const cpp::array<uint64_t, WORDCOUNT> &words) {
+  LIBC_INLINE constexpr explicit BigInt(const cpp::array<uint64_t, WORDCOUNT> &words) {
     for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] = words[i];
   }
 
   template <typename T, typename = cpp::enable_if_t<cpp::is_integral_v<T> &&
                                                     sizeof(T) <= 16 &&
                                                     !cpp::is_same_v<T, bool>>>
-  constexpr explicit operator T() const {
+  LIBC_INLINE constexpr explicit operator T() const {
     if constexpr (sizeof(T) <= 8)
       return static_cast<T>(val[0]);
 
     // T is 128-bit.
     T lo = static_cast<T>(val[0]);
 
     if constexpr (Bits == 64) {
       if constexpr (Signed) {
         // Extend sign for negative numbers.
         return (val[0] >> 63) ? ((T(-1) << 64) + lo) : lo;
       } else {
         return lo;
       }
     } else {
       return (static_cast<T>(val[1]) << 64) + lo;
     }
   }
 
-  constexpr explicit operator bool() const { return !is_zero(); }
+  LIBC_INLINE constexpr explicit operator bool() const { return !is_zero(); }
 
   BigInt<Bits, Signed> &operator=(const BigInt<Bits, Signed> &other) = default;
 
-  constexpr bool is_zero() const {
+  LIBC_INLINE constexpr bool is_zero() const {
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != 0)
         return false;
     }
     return true;
   }
 
   // Add x to this number and store the result in this number.
   // Returns the carry value produced by the addition operation.
-  constexpr uint64_t add(const BigInt<Bits, Signed> &x) {
+  LIBC_INLINE constexpr uint64_t add(const BigInt<Bits, Signed> &x) {
     SumCarry<uint64_t> s{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       s = add_with_carry_const(val[i], x.val[i], s.carry);
       val[i] = s.sum;
     }
     return s.carry;
   }
 
-  BigInt<Bits, Signed> operator+(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator+(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result;
     SumCarry<uint64_t> s{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       s = add_with_carry(val[i], other.val[i], s.carry);
       result.val[i] = s.sum;
     }
     return result;
   }
 
   // This will only apply when initializing a variable from constant values, so
   // it will always use the constexpr version of add_with_carry.
-  constexpr BigInt<Bits, Signed> operator+(BigInt<Bits, Signed> &&other) const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator+(BigInt<Bits, Signed> &&other) const {
     BigInt<Bits, Signed> result;
     SumCarry<uint64_t> s{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       s = add_with_carry_const(val[i], other.val[i], s.carry);
       result.val[i] = s.sum;
     }
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator+=(const BigInt<Bits, Signed> &other) {
     add(other); // Returned carry value is ignored.
     return *this;
   }
 
   // Subtract x to this number and store the result in this number.
   // Returns the carry value produced by the subtraction operation.
-  constexpr uint64_t sub(const BigInt<Bits, Signed> &x) {
+  LIBC_INLINE constexpr uint64_t sub(const BigInt<Bits, Signed> &x) {
     DiffBorrow<uint64_t> d{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       d = sub_with_borrow_const(val[i], x.val[i], d.borrow);
       val[i] = d.diff;
     }
     return d.borrow;
   }
 
-  BigInt<Bits, Signed> operator-(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE BigInt<Bits, Signed> operator-(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result;
     DiffBorrow<uint64_t> d{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       d = sub_with_borrow(val[i], other.val[i], d.borrow);
       result.val[i] = d.diff;
     }
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> operator-(BigInt<Bits, Signed> &&other) const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator-(BigInt<Bits, Signed> &&other) const {
     BigInt<Bits, Signed> result;
     DiffBorrow<uint64_t> d{0, 0};
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       d = sub_with_borrow_const(val[i], other.val[i], d.borrow);
       result.val[i] = d.diff;
     }
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator-=(const BigInt<Bits, Signed> &other) {
     // TODO(lntue): Set overflow flag / errno when carry is true.
     sub(other);
     return *this;
   }
 
   // Multiply this number with x and store the result in this number. It is
   // implemented using the long multiplication algorithm by splitting the
   // 64-bit words of this number and |x| in to 32-bit halves but peforming
   // the operations using 64-bit numbers. This ensures that we don't lose the
   // carry bits.
   // Returns the carry value produced by the multiplication operation.
-  constexpr uint64_t mul(uint64_t x) {
+  LIBC_INLINE constexpr uint64_t mul(uint64_t x) {
     BigInt<128, Signed> partial_sum(0);
     uint64_t carry = 0;
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       NumberPair<uint64_t> prod = full_mul(val[i], x);
       BigInt<128, Signed> tmp({prod.lo, prod.hi});
       carry += partial_sum.add(tmp);
       val[i] = partial_sum.val[0];
       partial_sum.val[0] = partial_sum.val[1];
       partial_sum.val[1] = carry;
       carry = 0;
     }
     return partial_sum.val[1];
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator*(const BigInt<Bits, Signed> &other) const {
     if constexpr (Signed) {
       BigInt<Bits, false> a(*this);
       BigInt<Bits, false> b(other);
       bool a_neg = (a.val[WORDCOUNT - 1] >> 63);
       bool b_neg = (b.val[WORDCOUNT - 1] >> 63);
       if (a_neg)
         a = -a;
if constexpr (Signed) {
         }
         return result;
       }
     }
   }
 
   // Return the full product, only unsigned for now.
   template <size_t OtherBits>
-  constexpr BigInt<Bits + OtherBits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits + OtherBits, Signed>
   ful_mul(const BigInt<OtherBits, Signed> &other) const {
     BigInt<Bits + OtherBits, Signed> result(0);
     BigInt<128, Signed> partial_sum(0);
     uint64_t carry = 0;
     constexpr size_t OTHER_WORDCOUNT = BigInt<OtherBits, Signed>::WORDCOUNT;
     for (size_t i = 0; i <= WORDCOUNT + OTHER_WORDCOUNT - 2; ++i) {
       const size_t lower_idx =
           i < OTHER_WORDCOUNT ? 0 : i - OTHER_WORDCOUNT + 1;
template <size_t Bits, bool Signed> struct BigInt {
   // Performance summary:
   //   Number of 64-bit x 64-bit -> 128-bit multiplications performed.
   //   Bits  WORDCOUNT  ful_mul  quick_mul_hi  Error bound
   //    128      2         4           3            1
   //    196      3         9           6            2
   //    256      4        16          10            3
   //    512      8        64          36            7
   constexpr BigInt<Bits, Signed>
-  quick_mul_hi(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE quick_mul_hi(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result(0);
     BigInt<128, Signed> partial_sum(0);
     uint64_t carry = 0;
     // First round of accumulation for those at WORDCOUNT - 1 in the full
     // product.
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       NumberPair<uint64_t> prod =
           full_mul(val[i], other.val[WORDCOUNT - 1 - i]);
for (size_t i = WORDCOUNT; i < 2 * WORDCOUNT - 1; ++i) {
       result.val[i - WORDCOUNT] = partial_sum.val[0];
     }
     result.val[WORDCOUNT - 1] = partial_sum.val[1];
     return result;
   }
 
   // pow takes a power and sets this to its starting value to that power. Zero
   // to the zeroth power returns 1.
-  constexpr void pow_n(uint64_t power) {
+  LIBC_INLINE constexpr void pow_n(uint64_t power) {
     BigInt<Bits, Signed> result = 1;
     BigInt<Bits, Signed> cur_power = *this;
 
     while (power > 0) {
       if ((power % 2) > 0) {
         result = result * cur_power;
       }
       power = power >> 1;
       cur_power *= cur_power;
     }
     *this = result;
   }
 
   // TODO: Make division work correctly for signed integers.
 
   // div takes another BigInt of the same size and divides this by it. The value
   // of this will be set to the quotient, and the return value is the remainder.
-  constexpr optional<BigInt<Bits, Signed>>
+  LIBC_INLINE constexpr optional<BigInt<Bits, Signed>>
   div(const BigInt<Bits, Signed> &other) {
     BigInt<Bits, Signed> remainder(0);
     if (*this < other) {
       remainder = *this;
       *this = BigInt<Bits, Signed>(0);
       return remainder;
     }
     if (other == 1) {
template <size_t Bits, bool Signed> struct BigInt {
   //   First, notice that:
   //     r % (2^e) = y % (2^e),
   // so we just need to focus on all the bits of y that is >= 2^e.
   //   To speed up the shift-and-add steps, we only use x as the divisor, and
   // performing 32-bit shiftings instead of bit-by-bit shiftings.
   //   Since the remainder of each division step < x < 2^32, the computation of
   // each step is now properly contained within uint64_t.
   //   And finally we perform some extra alignment steps for the remaining bits.
-  constexpr optional<BigInt<Bits, Signed>> div_uint32_times_pow_2(uint32_t x,
+  LIBC_INLINE constexpr optional<BigInt<Bits, Signed>> div_uint32_times_pow_2(uint32_t x,
                                                                   size_t e) {
     BigInt<Bits, Signed> remainder(0);
 
     if (x == 0) {
       return nullopt;
     }
     if (e >= Bits) {
       remainder = *this;
LIBC_INLINE constexpr optional<BigInt<Bits, Signed>> div_uint32_times_pow_2(uint32_t x,
     for (; pos > 0; --pos) {
       remainder[pos - 1] = val[pos - 1];
     }
 
     *this = quotient;
     return remainder;
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator/(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result(*this);
     result.div(other);
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator/=(const BigInt<Bits, Signed> &other) {
     div(other);
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator%(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result(*this);
     return *result.div(other);
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator*=(const BigInt<Bits, Signed> &other) {
     *this = *this * other;
     return *this;
   }
 
-  constexpr uint64_t clz() {
+  LIBC_INLINE constexpr uint64_t clz() {
     uint64_t leading_zeroes = 0;
     for (size_t i = WORDCOUNT; i > 0; --i) {
       if (val[i - 1] == 0) {
         leading_zeroes += sizeof(uint64_t) * 8;
       } else {
         leading_zeroes += unsafe_clz(val[i - 1]);
         break;
       }
     }
     return leading_zeroes;
   }
 
-  constexpr void shift_left(size_t s) {
+  LIBC_INLINE constexpr void shift_left(size_t s) {
 #ifdef __SIZEOF_INT128__
     if constexpr (Bits == 128) {
       // Use builtin 128 bits if available;
       if (s >= 128) {
         val[0] = 0;
         val[1] = 0;
         return;
       }
if (drop < WORDCOUNT) {
       }
     }
 
     for (size_t j = 0; j < i; ++j) {
       val[j] = 0;
     }
   }
 
-  constexpr BigInt<Bits, Signed> operator<<(size_t s) const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator<<(size_t s) const {
     BigInt<Bits, Signed> result(*this);
     result.shift_left(s);
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &operator<<=(size_t s) {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &operator<<=(size_t s) {
     shift_left(s);
     return *this;
   }
 
-  constexpr void shift_right(size_t s) {
+  LIBC_INLINE constexpr void shift_right(size_t s) {
 #ifdef __SIZEOF_INT128__
     if constexpr (Bits == 128) {
       // Use builtin 128 bits if available;
       if (s >= 128) {
         val[0] = 0;
         val[1] = 0;
         return;
       }
if (drop < WORDCOUNT) {
       }
     }
 
     for (; i < WORDCOUNT; ++i) {
       val[i] = sign;
     }
   }
 
-  constexpr BigInt<Bits, Signed> operator>>(size_t s) const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator>>(size_t s) const {
     BigInt<Bits, Signed> result(*this);
     result.shift_right(s);
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &operator>>=(size_t s) {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &operator>>=(size_t s) {
     shift_right(s);
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator&(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result;
     for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] & other.val[i];
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator&=(const BigInt<Bits, Signed> &other) {
     for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] &= other.val[i];
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator|(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result;
     for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] | other.val[i];
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator|=(const BigInt<Bits, Signed> &other) {
     for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] |= other.val[i];
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed>
+  LIBC_INLINE constexpr BigInt<Bits, Signed>
   operator^(const BigInt<Bits, Signed> &other) const {
     BigInt<Bits, Signed> result;
     for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = val[i] ^ other.val[i];
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> &
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &
   operator^=(const BigInt<Bits, Signed> &other) {
     for (size_t i = 0; i < WORDCOUNT; ++i)
       val[i] ^= other.val[i];
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed> operator~() const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator~() const {
     BigInt<Bits, Signed> result;
     for (size_t i = 0; i < WORDCOUNT; ++i)
       result.val[i] = ~val[i];
     return result;
   }
 
-  constexpr BigInt<Bits, Signed> operator-() const {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator-() const {
     BigInt<Bits, Signed> result = ~(*this);
     result.add(BigInt<Bits, Signed>(1));
     return result;
   }
 
-  constexpr bool operator==(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator==(const BigInt<Bits, Signed> &other) const {
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != other.val[i])
         return false;
     }
     return true;
   }
 
-  constexpr bool operator!=(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator!=(const BigInt<Bits, Signed> &other) const {
     for (size_t i = 0; i < WORDCOUNT; ++i) {
       if (val[i] != other.val[i])
         return true;
     }
     return false;
   }
 
-  constexpr bool operator>(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator>(const BigInt<Bits, Signed> &other) const {
     if constexpr (Signed) {
       // Check for different signs;
       bool a_sign = val[WORDCOUNT - 1] >> 63;
       bool b_sign = other.val[WORDCOUNT - 1] >> 63;
       if (a_sign != b_sign) {
         return b_sign;
       }
     }
     for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return true;
       else if (word < other_word)
         return false;
     }
     // Equal
     return false;
   }
 
-  constexpr bool operator>=(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator>=(const BigInt<Bits, Signed> &other) const {
     if constexpr (Signed) {
       // Check for different signs;
       bool a_sign = val[WORDCOUNT - 1] >> 63;
       bool b_sign = other.val[WORDCOUNT - 1] >> 63;
       if (a_sign != b_sign) {
         return b_sign;
       }
     }
     for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return true;
       else if (word < other_word)
         return false;
     }
     // Equal
     return true;
   }
 
-  constexpr bool operator<(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator<(const BigInt<Bits, Signed> &other) const {
     if constexpr (Signed) {
       // Check for different signs;
       bool a_sign = val[WORDCOUNT - 1] >> 63;
       bool b_sign = other.val[WORDCOUNT - 1] >> 63;
       if (a_sign != b_sign) {
         return a_sign;
       }
     }
 
     for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return false;
       else if (word < other_word)
         return true;
     }
     // Equal
     return false;
   }
 
-  constexpr bool operator<=(const BigInt<Bits, Signed> &other) const {
+  LIBC_INLINE constexpr bool operator<=(const BigInt<Bits, Signed> &other) const {
     if constexpr (Signed) {
       // Check for different signs;
       bool a_sign = val[WORDCOUNT - 1] >> 63;
       bool b_sign = other.val[WORDCOUNT - 1] >> 63;
       if (a_sign != b_sign) {
         return a_sign;
       }
     }
     for (size_t i = WORDCOUNT; i > 0; --i) {
       uint64_t word = val[i - 1];
       uint64_t other_word = other.val[i - 1];
       if (word > other_word)
         return false;
       else if (word < other_word)
         return true;
     }
     // Equal
     return true;
   }
 
-  constexpr BigInt<Bits, Signed> &operator++() {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &operator++() {
     BigInt<Bits, Signed> one(1);
     add(one);
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed> operator++(int) {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator++(int) {
     BigInt<Bits, Signed> oldval(*this);
     BigInt<Bits, Signed> one(1);
     add(one);
     return oldval;
   }
 
-  constexpr BigInt<Bits, Signed> &operator--() {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> &operator--() {
     BigInt<Bits, Signed> one(1);
     sub(one);
     return *this;
   }
 
-  constexpr BigInt<Bits, Signed> operator--(int) {
+  LIBC_INLINE constexpr BigInt<Bits, Signed> operator--(int) {
     BigInt<Bits, Signed> oldval(*this);
     BigInt<Bits, Signed> one(1);
     sub(one);
     return oldval;
   }
 
   // Return the i-th 64-bit word of the number.
-  constexpr const uint64_t &operator[](size_t i) const { return val[i]; }
+  LIBC_INLINE constexpr const uint64_t &operator[](size_t i) const { return val[i]; }
 
   // Return the i-th 64-bit word of the number.
-  constexpr uint64_t &operator[](size_t i) { return val[i]; }
+  LIBC_INLINE constexpr uint64_t &operator[](size_t i) { return val[i]; }
 
-  uint64_t *data() { return val; }
+  LIBC_INLINE uint64_t *data() { return val; }
 
-  const uint64_t *data() const { return val; }
+  LIBC_INLINE const uint64_t *data() const { return val; }
 };
 
 template <size_t Bits> using UInt = BigInt<Bits, false>;
 
 template <size_t Bits> using Int = BigInt<Bits, true>;
 
 // Provides limits of U/Int<128>.
 template <> class numeric_limits<UInt<128>> {
 public:
-  static constexpr UInt<128> max() {
+  LIBC_INLINE static constexpr UInt<128> max() {
     return UInt<128>({0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff});
   }
   static constexpr UInt<128> min() { return UInt<128>(0); }
 };
 
 template <> class numeric_limits<Int<128>> {
 public:
-  static constexpr Int<128> max() {
+  LIBC_INLINE static constexpr Int<128> max() {
     return Int<128>({0xffff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff});
   }
-  static constexpr Int<128> min() {
+  LIBC_INLINE static constexpr Int<128> min() {
     return Int<128>({0, 0x8000'0000'0000'0000});
   }
 };
 
 // Provides is_integral of U/Int<128>, U/Int<192>, U/Int<256>.
 template <size_t Bits, bool Signed>
 struct is_integral<BigInt<Bits, Signed>> : cpp::true_type {
   static_assert(Bits > 0 && Bits % 64 == 0,

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

LIBC_INLINE ErrorOr<void *> alloc_stack(size_t stacksize, size_t guardsize) {
   }
   mmap_result += guardsize;
   return reinterpret_cast<void *>(mmap_result);
 }
 
 // This must always be inlined as we may be freeing the calling threads stack in
 // which case a normal return from the top the stack would cause an invalid
 // memory read.
-static __attribute__((always_inline)) inline void
+[[gnu::always_inline]] LIBC_INLINE void
 free_stack(void *stack, size_t stacksize, size_t guardsize) {
   uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
   stackaddr -= guardsize;
   stack = reinterpret_cast<void *>(stackaddr);
   __llvm_libc::syscall_impl(SYS_munmap, stack, stacksize + guardsize);
 }
 
 struct Thread;
 
 // We align the start args to 16-byte boundary as we adjust the allocated
 // stack memory with its size. We want the adjusted address to be at a
 // 16-byte boundary to satisfy the x86_64 and aarch64 ABI requirements.
 // If different architecture in future requires higher alignment, then we
 // can add a platform specific alignment spec.
 struct alignas(STACK_ALIGNMENT) StartArgs {
   ThreadAttributes *thread_attrib;
   ThreadRunner runner;
   void *arg;
 };
 
 // This must always be inlined as we may be freeing the calling threads stack in
 // which case a normal return from the top the stack would cause an invalid
 // memory read.
-static __attribute__((always_inline)) inline void
+[[gnu::always_inline]] LIBC_INLINE void
 cleanup_thread_resources(ThreadAttributes *attrib) {
   // Cleanup the TLS before the stack as the TLS information is stored on
   // the stack.
   cleanup_tls(attrib->tls, attrib->tls_size);
   if (attrib->owned_stack)
     free_stack(attrib->stack, attrib->stacksize, attrib->guardsize);
 }
 
-__attribute__((always_inline)) inline uintptr_t get_start_args_addr() {
+[[gnu::always_inline]] LIBC_INLINE uintptr_t get_start_args_addr() {
 // NOTE: For __builtin_frame_address to work reliably across compilers,
 // architectures and various optimization levels, the TU including this file
 // should be compiled with -fno-omit-frame-pointer.
 #ifdef LIBC_TARGET_ARCH_IS_X86_64
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(0))
          // The x86_64 call instruction pushes resume address on to the stack.
          // Next, The x86_64 SysV ABI requires that the frame pointer be pushed
          // on to the stack. So, we have to step past two 64-bit values to get
          // to the start args.
          + sizeof(uintptr_t) * 2;
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   // The frame pointer after cloning the new thread in the Thread::run method
   // is set to the stack pointer where start args are stored. So, we fetch
   // from there.
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(1));
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
   // The current frame pointer is the previous stack pointer where the start
   // args are stored.
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
 #endif
 }
 
-__attribute__((noinline)) static void start_thread() {
+[[gnu::noinline]] LIBC_INLINE void start_thread() {
   auto *start_args = reinterpret_cast<StartArgs *>(get_start_args_addr());
   auto *attrib = start_args->thread_attrib;
   self.attrib = attrib;
   self.attrib->atexit_callback_mgr = internal::get_thread_atexit_callback_mgr();
 
   if (attrib->style == ThreadStyle::POSIX) {
     attrib->retval.posix_retval =
         start_args->runner.posix_runner(start_args->arg);

libc/src/stdio/printf_core/write_int_converter.h

 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-int inline convert_write_int(Writer *writer, const FormatSection &to_conv) {
+LIBC_INLINE int convert_write_int(Writer *writer,
+                                  const FormatSection &to_conv) {
 
   // This is an additional check added by LLVM-libc. The reason it returns -3 is
   // because printf uses negative return values for errors, and -1 and -2 are
   // already in use by the file_writer class for file errors.
   if (to_conv.conv_val_ptr == nullptr)
     return NULLPTR_WRITE_ERROR;
 
   int written = writer->get_chars_written();

libc/src/string/memory_utils/op_aarch64.h

 #include "src/string/memory_utils/op_generic.h"
 
 #ifdef __ARM_NEON
 #include <arm_neon.h>
 #endif //__ARM_NEON
 
 namespace __llvm_libc::aarch64 {
 
-static inline constexpr bool kNeon = LLVM_LIBC_IS_DEFINED(__ARM_NEON);
+LIBC_INLINE_VAR constexpr bool kNeon = LLVM_LIBC_IS_DEFINED(__ARM_NEON);
 
 namespace neon {
 
 struct BzeroCacheLine {
   static constexpr size_t SIZE = 64;
 
   LIBC_INLINE static void block(Ptr dst, uint8_t) {
 #if __SIZEOF_POINTER__ == 4
do {
       block(dst + offset, value);
       offset += SIZE;
     } while (offset < count - SIZE);
     // Unaligned store, we can't use 'dc zva' here.
     generic::Memset<generic_v512>::tail(dst, value, count);
   }
 };
 
-LIBC_INLINE static bool hasZva() {
+LIBC_INLINE bool hasZva() {
   uint64_t zva_val;
   asm("mrs %[zva_val], dczid_el0" : [zva_val] "=r"(zva_val));
   // DC ZVA is permitted if DZP, bit [4] is zero.
   // BS, bits [3:0] is log2 of the block count in words.
   // So the next line checks whether the instruction is permitted and block
   // count is 16 words (i.e. 64 bytes).
   return (zva_val & 0b11111) == 0b00100;
 }

libc/src/string/memory_utils/op_generic.h

 
 ///////////////////////////////////////////////////////////////////////////////
 // Low level operations for Bcmp and Memcmp that operate on memory locations.
 ///////////////////////////////////////////////////////////////////////////////
 
 // Same as load above but with an offset to the pointer.
 // Making the offset explicit hints the compiler to use relevant addressing mode
 // consistently.
-template <typename T> LIBC_INLINE static T load(CPtr ptr, size_t offset) {
+template <typename T> LIBC_INLINE T load(CPtr ptr, size_t offset) {
   return ::__llvm_libc::load<T>(ptr + offset);
 }
 
 // Same as above but also makes sure the loaded value is in big endian format.
 // This is useful when implementing lexicograhic comparisons as big endian
 // scalar comparison directly maps to lexicographic byte comparisons.
-template <typename T> LIBC_INLINE static T load_be(CPtr ptr, size_t offset) {
+template <typename T> LIBC_INLINE T load_be(CPtr ptr, size_t offset) {
   return Endian::to_big_endian(load<T>(ptr, offset));
 }
 
 // Equality: returns true iff values at locations (p1 + offset) and (p2 +
 // offset) compare equal.
-template <typename T> static bool eq(CPtr p1, CPtr p2, size_t offset);
+template <typename T> LIBC_INLINE bool eq(CPtr p1, CPtr p2, size_t offset);
 
 // Not equals: returns non-zero iff values at locations (p1 + offset) and (p2 +
 // offset) differ.
-template <typename T> static uint32_t neq(CPtr p1, CPtr p2, size_t offset);
+template <typename T> LIBC_INLINE uint32_t neq(CPtr p1, CPtr p2, size_t offset);
 
 // Lexicographic comparison:
 // - returns 0 iff values at locations (p1 + offset) and (p2 + offset) compare
 //   equal.
 // - returns a negative value if value at location (p1 + offset) is
 //   lexicographically less than value at (p2 + offset).
 // - returns a positive value if value at location (p1 + offset) is
 //   lexicographically greater than value at (p2 + offset).
 template <typename T>
-static MemcmpReturnType cmp(CPtr p1, CPtr p2, size_t offset);
+LIBC_INLINE MemcmpReturnType cmp(CPtr p1, CPtr p2, size_t offset);
 
 // Lexicographic comparison of non-equal values:
 // - returns a negative value if value at location (p1 + offset) is
 //   lexicographically less than value at (p2 + offset).
 // - returns a positive value if value at location (p1 + offset) is
 //   lexicographically greater than value at (p2 + offset).
 template <typename T>
-static MemcmpReturnType cmp_neq(CPtr p1, CPtr p2, size_t offset);
+LIBC_INLINE MemcmpReturnType cmp_neq(CPtr p1, CPtr p2, size_t offset);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcmp implementation
 //
 // When building memcmp, not all types are considered equals.
 //
 // For instance, the lexicographic comparison of two uint8_t can be implemented
 // as a simple subtraction, but for wider operations the logic can be much more

 }
 template <>
 LIBC_INLINE MemcmpReturnType cmp<uint8_t>(CPtr p1, CPtr p2, size_t offset) {
   return static_cast<int32_t>(load<uint8_t>(p1, offset)) -
          static_cast<int32_t>(load<uint8_t>(p2, offset));
 }
 template <>
 LIBC_INLINE MemcmpReturnType cmp_neq<uint8_t>(CPtr p1, CPtr p2, size_t offset);
+
 } // namespace __llvm_libc::generic
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_OP_GENERIC_H

libc/src/string/memory_utils/op_x86.h

 LIBC_INLINE_VAR constexpr bool kAvx = LLVM_LIBC_IS_DEFINED(__AVX__);
 LIBC_INLINE_VAR constexpr bool kAvx2 = LLVM_LIBC_IS_DEFINED(__AVX2__);
 LIBC_INLINE_VAR constexpr bool kAvx512F = LLVM_LIBC_IS_DEFINED(__AVX512F__);
 LIBC_INLINE_VAR constexpr bool kAvx512BW = LLVM_LIBC_IS_DEFINED(__AVX512BW__);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcpy repmovsb implementation
 struct Memcpy {
-  static void repmovsb(void *dst, const void *src, size_t count) {
+  LIBC_INLINE static void repmovsb(void *dst, const void *src, size_t count) {
     asm volatile("rep movsb" : "+D"(dst), "+S"(src), "+c"(count) : : "memory");
   }
 };
 
 } // namespace __llvm_libc::x86
 
 namespace __llvm_libc::generic {
 

libc/src/string/memory_utils/strcmp_implementations.h

 //===-- str{,case}cmp 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_STRCMP_IMPLEMENTATIONS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRCMP_IMPLEMENTATIONS_H
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-constexpr static int strcmp_implementation(const char *left, const char *right,
-                                           Comp &&comp) {
+LIBC_INLINE constexpr int
+strcmp_implementation(const char *left, const char *right, Comp &&comp) {
   // TODO: Look at benefits for comparing words at a time.
   for (; *left && !comp(*left, *right); ++left, ++right)
     ;
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 template <typename Comp>
-constexpr static int strncmp_implementation(const char *left, const char *right,
-                                            size_t n, Comp &&comp) {
+LIBC_INLINE constexpr int strncmp_implementation(const char *left,
+                                                 const char *right, size_t n,
+                                                 Comp &&comp) {
   if (n == 0)
     return 0;
 
   // TODO: Look at benefits for comparing words at a time.
   for (; n > 1; --n, ++left, ++right) {
     char lc = *left;
     if (!comp(lc, '\0') || comp(lc, *right))
       break;
   }
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/strstr_implementations.h

 
 #include "src/string/memory_utils/memmem_implementations.h"
 #include "src/string/string_utils.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-constexpr static char *strstr_implementation(const char *haystack,
-                                             const char *needle, Comp &&comp) {
+LIBC_INLINE constexpr char *
+strstr_implementation(const char *haystack, const char *needle, Comp &&comp) {
   void *result = memmem_implementation(
       static_cast<const void *>(haystack), internal::string_length(haystack),
       static_cast<const void *>(needle), internal::string_length(needle), comp);
   return static_cast<char *>(result);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRSTR_IMPLEMENTATIONS_H

libc/src/string/memory_utils/utils.h

 
 #include <stddef.h> // size_t
 #include <stdint.h> // intptr_t / uintptr_t / INT32_MAX / INT32_MIN
 
 namespace __llvm_libc {
 
 // Allows compile time error reporting in `if constexpr` branches.
 template <bool flag = false>
-static void deferred_static_assert(const char *msg) {
+LIBC_INLINE void deferred_static_assert(const char *msg) {
   static_assert(flag, "compilation error");
   (void)msg;
 }
 
 // Return whether `value` is zero or a power of two.
-static constexpr bool is_power2_or_zero(size_t value) {
+LIBC_INLINE constexpr bool is_power2_or_zero(size_t value) {
   return (value & (value - 1U)) == 0;
 }
 
 // Return whether `value` is a power of two.
-static constexpr bool is_power2(size_t value) {
+LIBC_INLINE constexpr bool is_power2(size_t value) {
   return value && is_power2_or_zero(value);
 }
 
 // Compile time version of log2 that handles 0.
-static constexpr size_t log2s(size_t value) {
+LIBC_INLINE constexpr size_t log2s(size_t value) {
   return (value == 0 || value == 1) ? 0 : 1 + log2s(value / 2);
 }
 
 // Returns the first power of two preceding value or value if it is already a
 // power of two (or 0 when value is 0).
-static constexpr size_t le_power2(size_t value) {
+LIBC_INLINE constexpr size_t le_power2(size_t value) {
   return value == 0 ? value : 1ULL << log2s(value);
 }
 
 // Returns the first power of two following value or value if it is already a
 // power of two (or 0 when value is 0).
-static constexpr size_t ge_power2(size_t value) {
+LIBC_INLINE constexpr size_t ge_power2(size_t value) {
   return is_power2_or_zero(value) ? value : 1ULL << (log2s(value) + 1);
 }
 
 // Returns the number of bytes to substract from ptr to get to the previous
 // multiple of alignment. If ptr is already aligned returns 0.
-template <size_t alignment> uintptr_t distance_to_align_down(const void *ptr) {
+template <size_t alignment>
+LIBC_INLINE uintptr_t distance_to_align_down(const void *ptr) {
   static_assert(is_power2(alignment), "alignment must be a power of 2");
   return reinterpret_cast<uintptr_t>(ptr) & (alignment - 1U);
 }
 
 // Returns the number of bytes to add to ptr to get to the next multiple of
 // alignment. If ptr is already aligned returns 0.
-template <size_t alignment> uintptr_t distance_to_align_up(const void *ptr) {
+template <size_t alignment>
+LIBC_INLINE uintptr_t distance_to_align_up(const void *ptr) {
   static_assert(is_power2(alignment), "alignment must be a power of 2");
   // The logic is not straightforward and involves unsigned modulo arithmetic
   // but the generated code is as fast as it can be.
   return -reinterpret_cast<uintptr_t>(ptr) & (alignment - 1U);
 }
 
 // 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>
-uintptr_t distance_to_next_aligned(const void *ptr) {
+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> static 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);

libc/src/string/string_utils.h

if (!size)
     return len;
   size_t n = len < size - 1 ? len : size - 1;
   inline_memcpy(dst, src, n);
   inline_bzero(dst + n, size - n);
   return len;
 }
 
 template <bool ReturnNull = true>
-constexpr static char *strchr_implementation(const char *src, int c) {
+LIBC_INLINE constexpr static char *strchr_implementation(const char *src,
+                                                         int c) {
   char ch = static_cast<char>(c);
   for (; *src && *src != ch; ++src)
     ;
   char *ret = ReturnNull ? nullptr : const_cast<char *>(src);
   return *src == ch ? const_cast<char *>(src) : ret;
 }
 
-constexpr static char *strrchr_implementation(const char *src, int c) {
+LIBC_INLINE constexpr static char *strrchr_implementation(const char *src,
+                                                          int c) {
   char ch = static_cast<char>(c);
   char *last_occurrence = nullptr;
   for (; *src; ++src) {
     if (*src == ch)
       last_occurrence = const_cast<char *>(src);
   }
   return last_occurrence;
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif //  LIBC_SRC_STRING_STRING_UTILS_H