[libc][WIP] clean up lint errors in strings

[michaelrj]

Summary

Very much WIP, there are still several lint errors and there are also
some changes to fix lint errors I'm not sure are correct.

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" // LIBC_INLINE
+
 #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.");
 
+  LIBC_INLINE constexpr array() = default;
+  LIBC_INLINE constexpr array(const array &) = default;
+  LIBC_INLINE ~array() = default;
+
   T Data[N];
 
   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/macros/config.h" // LIBC_HAS_BUILTIN
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
+#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");
 #if defined(LLVM_LIBC_HAS_BUILTIN_BIT_CAST)
   return __builtin_bit_cast(To, from);
 #else
   To to;
   char *dst = reinterpret_cast<char *>(&to);
   const char *src = reinterpret_cast<const char *>(&from);
 #if defined(LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE)

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 <stddef.h> // For size_t.
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
+#include <stddef.h>                          // For size_t.
 
 namespace __llvm_libc::cpp {
 
 template <size_t NumberOfBits> struct bitset {
+
+  LIBC_INLINE constexpr bitset() = default;
+  LIBC_INLINE constexpr bitset(const bitset &) = default;
+  LIBC_INLINE ~bitset() = default;
+
   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 "type_traits.h" // For enable_if_t, is_integral_v.
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
+#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/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
 
 namespace __llvm_libc {
 namespace cpp {
 
+// To avoid the linter requesting explicit constructors/destructors for these
+// template-only classes, this file is marked as nolint.
+// NOLINTBEGIN
+
 template <bool B, typename T> struct enable_if;
-template <typename T> struct enable_if<true, T> { using type = T; };
+template <typename T> struct enable_if<true, T> {
+  using type = 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;
 };
 using true_type = cpp::integral_constant<bool, true>;
 using false_type = cpp::integral_constant<bool, false>;
 
-template <typename T> struct type_identity { using type = T; };
+template <typename T> struct type_identity {
+  using type = T;
+};
 
 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;
 
 template <class T> struct is_const : cpp::false_type {};
 template <class T> struct is_const<const T> : cpp::true_type {};
template <typename T> struct is_unsigned {
   static constexpr bool value = is_arithmetic<T>::value && (T(-1) > T(0));
   constexpr operator bool() const { return value; }
   constexpr bool operator()() const { return value; }
 };
 template <typename T>
 inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
 
 template <typename T> struct make_unsigned;
-template <> struct make_unsigned<char> { using type = unsigned char; };
-template <> struct make_unsigned<signed char> { using type = unsigned char; };
-template <> struct make_unsigned<short> { using type = unsigned short; };
-template <> struct make_unsigned<int> { using type = unsigned int; };
-template <> struct make_unsigned<long> { using type = unsigned long; };
+template <> struct make_unsigned<char> {
+  using type = unsigned char;
+};
+template <> struct make_unsigned<signed char> {
+  using type = unsigned char;
+};
+template <> struct make_unsigned<short> {
+  using type = unsigned short;
+};
+template <> struct make_unsigned<int> {
+  using type = unsigned int;
+};
+template <> struct make_unsigned<long> {
+  using type = unsigned long;
+};
 template <> struct make_unsigned<long long> {
   using type = unsigned long long;
 };
-template <> struct make_unsigned<unsigned char> { using type = unsigned char; };
+template <> struct make_unsigned<unsigned char> {
+  using type = unsigned char;
+};
 template <> struct make_unsigned<unsigned short> {
   using type = unsigned short;
 };
-template <> struct make_unsigned<unsigned int> { using type = unsigned int; };
-template <> struct make_unsigned<unsigned long> { using type = unsigned long; };
+template <> struct make_unsigned<unsigned int> {
+  using type = unsigned int;
+};
+template <> struct make_unsigned<unsigned long> {
+  using type = unsigned long;
+};
 template <> struct make_unsigned<unsigned long long> {
   using type = unsigned long long;
 };
 #ifdef __SIZEOF_INT128__
-template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };
-template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
+template <> struct make_unsigned<__int128_t> {
+  using type = __uint128_t;
+};
+template <> struct make_unsigned<__uint128_t> {
+  using type = __uint128_t;
+};
 #endif
 template <typename T> using make_unsigned_t = typename make_unsigned<T>::type;
 
 // Compile time type selection.
 template <bool B, typename T, typename F> struct conditional {
   using type = T;
 };
 template <typename T, typename F> struct conditional<false, T, F> {
   using type = F;
 };
 template <bool B, typename T, typename F>
 using conditional_t = typename conditional<B, T, F>::type;
 
+// NOLINTEND
+
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H

libc/src/__support/common.h

#define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
   decltype(__llvm_libc::name) name [[gnu::alias(#name)]];                      \
   type __##name##_impl__ arglist
 #else
 #define LLVM_LIBC_FUNCTION(type, name, arglist) type name arglist
 #endif
 
 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/endian.h

 
 template <unsigned ORDER> struct Endian {
   static constexpr const bool IS_LITTLE = ORDER == __ORDER_LITTLE_ENDIAN__;
   static constexpr const bool IS_BIG = ORDER == __ORDER_BIG_ENDIAN__;
   template <typename T> static T to_big_endian(T value);
   template <typename T> static T to_little_endian(T value);
 };
 
+// NOLINTBEGIN
+
 // Little Endian specializations
 template <>
 template <>
 LIBC_INLINE uint8_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;
 }
 template <>

 }
 template <>
 template <>
 LIBC_INLINE uint64_t
 Endian<__ORDER_BIG_ENDIAN__>::to_little_endian<uint64_t>(uint64_t v) {
   return __builtin_bswap64(v);
 }
 
+// NOLINTEND
+
 } // namespace internal
 
 using Endian = internal::Endian<__BYTE_ORDER__>;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ENDIAN_H

libc/src/__support/macros/optimization.h

 
 #include "src/__support/macros/config.h"              // LIBC_HAS_BUILTIN
 #include "src/__support/macros/properties/compiler.h" // LIBC_COMPILER_IS_CLANG
 
 // We use a template to implement likely/unlikely to make sure that we don't
 // accidentally pass an integer.
 namespace __llvm_libc::details {
 template <typename T>
-constexpr LIBC_INLINE bool expects_bool_condition(T value, T expected) {
+LIBC_INLINE constexpr bool expects_bool_condition(T value, T expected) {
   return __builtin_expect(value, expected);
 }
 } // namespace __llvm_libc::details
 #define LIBC_LIKELY(x) __llvm_libc::details::expects_bool_condition(x, true)
 #define LIBC_UNLIKELY(x) __llvm_libc::details::expects_bool_condition(x, false)
 
 #if defined(LIBC_COMPILER_IS_CLANG)
 #define LIBC_LOOP_NOUNROLL _Pragma("nounroll")
 #elif defined(LIBC_COMPILER_IS_GCC)
 #define LIBC_LOOP_NOUNROLL _Pragma("GCC unroll 0")
 #else
 #error "Unhandled compiler"
 #endif
 
 #endif /* LLVM_LIBC_SRC_SUPPORT_MACROS_OPTIMIZATION_H */

libc/src/string/memory_utils/op_generic.h

 template <typename... Pairs> struct CTMap : public Pairs... {
   using Pairs::get_pair...;
   template <size_t I>
   using find_type =
       typename decltype(get_pair(cpp::integral_constant<size_t, I>{}))::type;
 };
 
 // Helper to test if a type is void.
-template <typename T> inline constexpr bool is_void_v = cpp::is_same_v<T, void>;
+template <typename T> inline constexpr bool IS_VOID_V = cpp::is_same_v<T, void>;
 
 // Implements load, store and splat for unsigned integral types.
 template <typename T> struct ScalarType {
   using Type = T;
   static_assert(cpp::is_integral_v<Type> && !cpp::is_signed_v<Type>);
 
   LIBC_INLINE static Type load(CPtr src) {
     return ::__llvm_libc::load<Type>(src);
template <size_t Size> struct VectorType {
   using Type = typename VectorValueType<Size>::type;
   LIBC_INLINE static Type load(CPtr src) {
     return ::__llvm_libc::load<Type>(src);
   }
   LIBC_INLINE static void store(Ptr dst, Type value) {
     ::__llvm_libc::store<Type>(dst, value);
   }
   LIBC_INLINE static Type splat(uint8_t value) {
-    Type Out;
+    Type out;
     // This for loop is optimized out for vector types.
     for (size_t i = 0; i < Size; ++i)
-      Out[i] = static_cast<uint8_t>(value);
-    return Out;
+      out[i] = static_cast<uint8_t>(value);
+    return out;
   }
 };
 
 static_assert((UINTPTR_MAX == 4294967295U) ||
                   (UINTPTR_MAX == 18446744073709551615UL),
               "We currently only support 32- or 64-bit platforms");
 
 #if defined(LIBC_TARGET_ARCH_IS_X86_64) || defined(LIBC_TARGET_ARCH_IS_AARCH64)
#endif                                     //
           CTPair<16, VectorType<16>>,      //
           CTPair<32, VectorType<32>>,      //
           CTPair<64, VectorType<64>>>;
 
 // Implements load, store and splat for sizes not natively supported by the
 // platform. SubType is either ScalarType or VectorType.
 template <typename SubType, size_t ArraySize> struct ArrayType {
   using Type = cpp::array<typename SubType::Type, ArraySize>;
-  static constexpr size_t SizeOfElement = sizeof(typename SubType::Type);
+  static constexpr size_t SIZE_OF_ELEMENT = sizeof(typename SubType::Type);
   LIBC_INLINE static Type load(CPtr src) {
-    Type Value;
-    for (size_t I = 0; I < ArraySize; ++I)
-      Value[I] = SubType::load(src + (I * SizeOfElement));
-    return Value;
-  }
-  LIBC_INLINE static void store(Ptr dst, Type Value) {
-    for (size_t I = 0; I < ArraySize; ++I)
-      SubType::store(dst + (I * SizeOfElement), Value[I]);
+    Type value;
+    for (size_t i = 0; i < ArraySize; ++i)
+      value[i] = SubType::load(src + (i * SIZE_OF_ELEMENT));
+    return value;
+  }
+  LIBC_INLINE static void store(Ptr dst, Type value) {
+    for (size_t i = 0; i < ArraySize; ++i)
+      SubType::store(dst + (i * SIZE_OF_ELEMENT), value[i]);
   }
   LIBC_INLINE static Type splat(uint8_t value) {
-    Type Out;
-    for (size_t I = 0; I < ArraySize; ++I)
-      Out[I] = SubType::splat(value);
-    return Out;
+    Type out;
+    for (size_t i = 0; i < ArraySize; ++i)
+      out[i] = SubType::splat(value);
+    return out;
   }
 };
 
 // Checks whether we should use an ArrayType.
-template <size_t Size, size_t MaxSize> static constexpr bool useArrayType() {
-  return (Size > MaxSize) && ((Size % MaxSize) == 0) &&
-         !is_void_v<NativeTypeMap::find_type<MaxSize>>;
+template <size_t Size, size_t MAX_SIZE>
+LIBC_INLINE static constexpr bool use_array_type() {
+  return (Size > MAX_SIZE) && ((Size % MAX_SIZE) == 0) &&
+         !IS_VOID_V<NativeTypeMap::find_type<MAX_SIZE>>;
 }
 
 // Compute the type to handle an operation of Size bytes knowing that the
-// underlying platform only support native types up to MaxSize bytes.
-template <size_t Size, size_t MaxSize>
+// underlying platform only support native types up to MAX_SIZE bytes.
+template <size_t Size, size_t MAX_SIZE>
 using getTypeFor = cpp::conditional_t<
-    useArrayType<Size, MaxSize>(),
-    ArrayType<NativeTypeMap::find_type<MaxSize>, Size / MaxSize>,
+    use_array_type<Size, MAX_SIZE>(),
+    ArrayType<NativeTypeMap::find_type<MAX_SIZE>, Size / MAX_SIZE>,
     NativeTypeMap::find_type<Size>>;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcpy
 // When building with clang we can delegate to the builtin implementation.
 ///////////////////////////////////////////////////////////////////////////////
 
 template <size_t Size> using Memcpy = builtin::Memcpy<Size>;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memset
-// The MaxSize template argument gives the maximum size handled natively by the
+// The MAX_SIZE template argument gives the maximum size handled natively by the
 // platform. For instance on x86 with AVX support this would be 32. If a size
-// greater than MaxSize is requested we break the operation down in smaller
-// pieces of size MaxSize.
+// greater than MAX_SIZE is requested we break the operation down in smaller
+// pieces of size MAX_SIZE.
 ///////////////////////////////////////////////////////////////////////////////
-template <size_t Size, size_t MaxSize> struct Memset {
-  static_assert(is_power2(MaxSize));
+template <size_t Size, size_t MAX_SIZE> struct Memset {
+  static_assert(is_power2(MAX_SIZE));
   static constexpr size_t SIZE = Size;
 
   LIBC_INLINE static void block(Ptr dst, uint8_t value) {
     if constexpr (Size == 3) {
-      Memset<1, MaxSize>::block(dst + 2, value);
-      Memset<2, MaxSize>::block(dst, value);
+      Memset<1, MAX_SIZE>::block(dst + 2, value);
+      Memset<2, MAX_SIZE>::block(dst, value);
     } else {
-      using T = getTypeFor<Size, MaxSize>;
-      if constexpr (is_void_v<T>) {
+      using T = getTypeFor<Size, MAX_SIZE>;
+      if constexpr (IS_VOID_V<T>) {
         deferred_static_assert("Unimplemented Size");
       } else {
         T::store(dst, T::splat(value));
       }
     }
   }
 
   LIBC_INLINE static void tail(Ptr dst, uint8_t value, size_t count) {
template <size_t Size, size_t MAX_SIZE> struct Memset {
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Bcmp
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t Size> struct Bcmp {
   static constexpr size_t SIZE = Size;
-  static constexpr size_t MaxSize = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
+  static constexpr size_t MAX_SIZE = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
                                          ? sizeof(uint64_t)
                                          : sizeof(uint32_t);
 
   template <typename T> LIBC_INLINE static uint32_t load_xor(CPtr p1, CPtr p2) {
     return load<T>(p1) ^ load<T>(p2);
   }
 
   template <typename T>
   LIBC_INLINE static uint32_t load_not_equal(CPtr p1, CPtr p2) {
     return load<T>(p1) != load<T>(p2);
   }
 
   LIBC_INLINE static BcmpReturnType block(CPtr p1, CPtr p2) {
     if constexpr (Size == 1) {
       return load_xor<uint8_t>(p1, p2);
     } else if constexpr (Size == 2) {
       return load_xor<uint16_t>(p1, p2);
     } else if constexpr (Size == 4) {
       return load_xor<uint32_t>(p1, p2);
     } else if constexpr (Size == 8) {
       return load_not_equal<uint64_t>(p1, p2);
-    } else if constexpr (useArrayType<Size, MaxSize>()) {
-      for (size_t offset = 0; offset < Size; offset += MaxSize)
-        if (auto value = Bcmp<MaxSize>::block(p1 + offset, p2 + offset))
+    } else if constexpr (use_array_type<Size, MAX_SIZE>()) {
+      for (size_t offset = 0; offset < Size; offset += MAX_SIZE)
+        if (auto value = Bcmp<MAX_SIZE>::block(p1 + offset, p2 + offset))
           return value;
     } else {
       deferred_static_assert("Unimplemented Size");
     }
     return BcmpReturnType::ZERO();
   }
 
   LIBC_INLINE static BcmpReturnType tail(CPtr p1, CPtr p2, size_t count) {
template <size_t Size> struct Bcmp {
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memcmp
 ///////////////////////////////////////////////////////////////////////////////
 template <size_t Size> struct Memcmp {
   static constexpr size_t SIZE = Size;
-  static constexpr size_t MaxSize = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
+  static constexpr size_t MAX_SIZE = LLVM_LIBC_IS_DEFINED(LLVM_LIBC_HAS_UINT64)
                                          ? sizeof(uint64_t)
                                          : sizeof(uint32_t);
 
   template <typename T> LIBC_INLINE static T load_be(CPtr ptr) {
     return Endian::to_big_endian(load<T>(ptr));
   }
 
   template <typename T>
   LIBC_INLINE static MemcmpReturnType load_be_diff(CPtr p1, CPtr p2) {
     return load_be<T>(p1) - load_be<T>(p2);
LIBC_INLINE static MemcmpReturnType block(CPtr p1, CPtr p2) {
     if constexpr (Size == 1) {
       return load_be_diff<uint8_t>(p1, p2);
     } else if constexpr (Size == 2) {
       return load_be_diff<uint16_t>(p1, p2);
     } else if constexpr (Size == 4) {
       return load_be_cmp<uint32_t>(p1, p2);
     } else if constexpr (Size == 8) {
       return load_be_cmp<uint64_t>(p1, p2);
-    } else if constexpr (useArrayType<Size, MaxSize>()) {
-      for (size_t offset = 0; offset < Size; offset += MaxSize)
-        if (Bcmp<MaxSize>::block(p1 + offset, p2 + offset))
-          return Memcmp<MaxSize>::block(p1 + offset, p2 + offset);
+    } else if constexpr (use_array_type<Size, MAX_SIZE>()) {
+      for (size_t offset = 0; offset < Size; offset += MAX_SIZE)
+        if (Bcmp<MAX_SIZE>::block(p1 + offset, p2 + offset))
+          return Memcmp<MAX_SIZE>::block(p1 + offset, p2 + offset);
       return MemcmpReturnType::ZERO();
     } else if constexpr (Size == 3) {
       if (auto value = Memcmp<2>::block(p1, p2))
         return value;
       return Memcmp<1>::block(p1 + 2, p2 + 2);
     } else {
       deferred_static_assert("Unimplemented Size");
     }
LIBC_INLINE static MemcmpReturnType loop_and_tail(CPtr p1, CPtr p2,
     return tail(p1, p2, count);
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Memmove
 ///////////////////////////////////////////////////////////////////////////////
 
-template <size_t Size, size_t MaxSize> struct Memmove {
-  static_assert(is_power2(MaxSize));
-  using T = getTypeFor<Size, MaxSize>;
+template <size_t Size, size_t MAX_SIZE> struct Memmove {
+  static_assert(is_power2(MAX_SIZE));
+  using T = getTypeFor<Size, MAX_SIZE>;
   static constexpr size_t SIZE = Size;
 
   LIBC_INLINE static void block(Ptr dst, CPtr src) {
-    if constexpr (is_void_v<T>) {
+    if constexpr (IS_VOID_V<T>) {
       deferred_static_assert("Unimplemented Size");
     } else {
       T::store(dst, T::load(src));
     }
   }
 
   LIBC_INLINE static void head_tail(Ptr dst, CPtr src, size_t count) {
     const size_t offset = count - Size;
-    if constexpr (is_void_v<T>) {
+    if constexpr (IS_VOID_V<T>) {
       deferred_static_assert("Unimplemented Size");
     } else {
       // The load and store operations can be performed in any order as long as
       // they are not interleaved. More investigations are needed to determine
       // the best order.
       const auto head = T::load(src);
       const auto tail = T::load(src + offset);
       T::store(dst, head);

libc/src/string/memory_utils/op_x86.h

 static inline constexpr bool kAvx = LLVM_LIBC_IS_DEFINED(__AVX__);
 static inline constexpr bool kAvx2 = LLVM_LIBC_IS_DEFINED(__AVX2__);
 static inline constexpr bool kAvx512F = LLVM_LIBC_IS_DEFINED(__AVX512F__);
 static inline 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");
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Bcmp
 
 // Base implementation for the Bcmp specializations.
template <size_t Size, size_t BlockSize, auto BlockBcmp> struct BcmpImpl {
   }
 };
 
 namespace sse2 {
 LIBC_INLINE BcmpReturnType bcmp16(CPtr p1, CPtr p2) {
 #if defined(__SSE2__)
   using T = char __attribute__((__vector_size__(16)));
   // A mask indicating which bytes differ after loading 16 bytes from p1 and p2.
-  const int mask =
-      _mm_movemask_epi8(cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2)));
+  const int mask = _mm_movemask_epi8( // NOLINT
+      cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2)));
   return static_cast<uint32_t>(mask);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__SSE2__)
 }
 template <size_t Size> using Bcmp = BcmpImpl<Size, 16, bcmp16>;
 } // namespace sse2
 
 namespace avx2 {
 LIBC_INLINE BcmpReturnType bcmp32(CPtr p1, CPtr p2) {
 #if defined(__AVX2__)
   using T = char __attribute__((__vector_size__(32)));
   // A mask indicating which bytes differ after loading 32 bytes from p1 and p2.
-  const int mask =
-      _mm256_movemask_epi8(cpp::bit_cast<__m256i>(load<T>(p1) != load<T>(p2)));
+  const int mask = _mm256_movemask_epi8( // NOLINT
+      cpp::bit_cast<__m256i>(load<T>(p1) != load<T>(p2)));
   // _mm256_movemask_epi8 returns an int but it is to be interpreted as a 32-bit
   // mask.
   return static_cast<uint32_t>(mask);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__AVX2__)
 }
 template <size_t Size> using Bcmp = BcmpImpl<Size, 32, bcmp32>;
 } // namespace avx2
 
 namespace avx512bw {
 LIBC_INLINE BcmpReturnType bcmp64(CPtr p1, CPtr p2) {
 #if defined(__AVX512BW__)
   using T = char __attribute__((__vector_size__(64)));
   // A mask indicating which bytes differ after loading 64 bytes from p1 and p2.
-  const uint64_t mask = _mm512_cmpneq_epi8_mask(
+  const uint64_t mask = _mm512_cmpneq_epi8_mask( // NOLINT
       cpp::bit_cast<__m512i>(load<T>(p1)), cpp::bit_cast<__m512i>(load<T>(p2)));
   const bool mask_is_set = mask != 0;
   return static_cast<uint32_t>(mask_is_set);
 #else
   (void)p1;
   (void)p2;
   return BcmpReturnType::ZERO();
 #endif // defined(__AVX512BW__)
struct MemcmpImpl {
   }
 };
 
 namespace sse2 {
 LIBC_INLINE MemcmpReturnType memcmp16(CPtr p1, CPtr p2) {
 #if defined(__SSE2__)
   using T = char __attribute__((__vector_size__(16)));
   // A mask indicating which bytes differ after loading 16 bytes from p1 and p2.
-  if (int mask =
-          _mm_movemask_epi8(cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2))))
+  if (int mask = _mm_movemask_epi8( // NOLINT
+          cpp::bit_cast<__m128i>(load<T>(p1) != load<T>(p2))))
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();
 #else
   (void)p1;
   (void)p2;
   return MemcmpReturnType::ZERO();
 #endif // defined(__SSE2__)
 }
 template <size_t Size> using Memcmp = MemcmpImpl<Size, 16, memcmp16, bcmp16>;
 } // namespace sse2
 
 namespace avx2 {
 LIBC_INLINE MemcmpReturnType memcmp32(CPtr p1, CPtr p2) {
 #if defined(__AVX2__)
   using T = char __attribute__((__vector_size__(32)));
   // A mask indicating which bytes differ after loading 32 bytes from p1 and p2.
-  if (int mask = _mm256_movemask_epi8(
+  if (int mask = _mm256_movemask_epi8( // NOLINT
           cpp::bit_cast<__m256i>(load<T>(p1) != load<T>(p2))))
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();
 #else
   (void)p1;
   (void)p2;
   return MemcmpReturnType::ZERO();
 #endif // defined(__AVX2__)
 }
 template <size_t Size> using Memcmp = MemcmpImpl<Size, 32, memcmp32, bcmp32>;
 } // namespace avx2
 
 namespace avx512bw {
 LIBC_INLINE MemcmpReturnType memcmp64(CPtr p1, CPtr p2) {
 #if defined(__AVX512BW__)
   using T = char __attribute__((__vector_size__(64)));
   // A mask indicating which bytes differ after loading 64 bytes from p1 and p2.
-  if (uint64_t mask =
-          _mm512_cmpneq_epi8_mask(cpp::bit_cast<__m512i>(load<T>(p1)),
-                                  cpp::bit_cast<__m512i>(load<T>(p2))))
+  if (uint64_t mask = _mm512_cmpneq_epi8_mask( // NOLINT
+          cpp::bit_cast<__m512i>(load<T>(p1)),
     return char_diff_no_zero(p1, p2, mask);
   return MemcmpReturnType::ZERO();
 #else
   (void)p1;
   (void)p2;
   return MemcmpReturnType::ZERO();
 #endif // defined(__AVX512BW__)
 }
 template <size_t Size> using Memcmp = MemcmpImpl<Size, 64, memcmp64, bcmp64>;
 } // namespace avx512bw
 
 } // namespace __llvm_libc::x86
 
 #endif // LIBC_TARGET_ARCH_IS_X86_64
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_OP_X86_H

libc/src/string/memory_utils/utils.h

 //===-- Memory utils --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_MEMORY_UTILS_UTILS_H
 #define LLVM_LIBC_SRC_MEMORY_UTILS_UTILS_H
 
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/cstddef.h"
 #include "src/__support/CPP/type_traits.h"
-#include "src/__support/macros/attributes.h"          //LIBC_INLINE
-#include "src/__support/macros/config.h"              // LIBC_HAS_BUILTIN
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
+#include "src/__support/macros/config.h"     // LIBC_HAS_BUILTIN
 
 #include <stddef.h> // size_t
 #include <stdint.h> // intptr_t / uintptr_t
 
 namespace __llvm_libc {
 
 // Allows compile time error reporting in `if constexpr` branches.
 template <bool flag = false>
 static 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 static 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 static 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 log2(size_t value) {
+LIBC_INLINE static constexpr size_t log2(size_t value) {
   return (value == 0 || value == 1) ? 0 : 1 + log2(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 static constexpr size_t le_power2(size_t value) {
   return value == 0 ? value : 1ULL << log2(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 static constexpr size_t ge_power2(size_t value) {
   return is_power2_or_zero(value) ? value : 1ULL << (log2(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) {
   static_assert(is_power2(alignment), "alignment must be a power of 2");
   return reinterpret_cast<uintptr_t>(ptr) & (alignment - 1U);

 
 // 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) {}
+  LIBC_INLINE ~StrictIntegralType() = default;
 
   // 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)}; }
 
 private:
   T value;
 };
 
 using MemcmpReturnType = StrictIntegralType<int32_t>;
 using BcmpReturnType = StrictIntegralType<uint32_t>;
 
 // Loads bytes from memory (possibly unaligned) and materializes them as
 // type.
 template <typename T> LIBC_INLINE T load(CPtr ptr) {
-  T Out;
-  memcpy_inline<sizeof(T)>(&Out, ptr);
-  return Out;
+  T out;
+  memcpy_inline<sizeof(T)>(&out, ptr);
+  return out;
 }
 
 // Stores a value of type T in memory (possibly unaligned).
 template <typename T> LIBC_INLINE void store(Ptr ptr, T value) {
   memcpy_inline<sizeof(T)>(ptr, &value);
 }
 
 // Advances the pointers p1 and p2 by offset bytes and decrease count by the

libc/src/string/string_utils.h

 // should be placed in allocating_string_utils.h intead.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBC_SRC_STRING_STRING_UTILS_H
 #define LIBC_SRC_STRING_STRING_UTILS_H
 
 #include "src/__support/CPP/bitset.h"
+#include "src/__support/common.h"              // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/bzero_implementations.h"
 #include "src/string/memory_utils/memcpy_implementations.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>

libc/utils/HdrGen/PublicAPICommand.cpp

void writeAPIFromIndex(APIIndexer &G,
 
   for (auto &TypeName : G.RequiredTypes) {
     if (G.TypeSpecMap.find(TypeName) == G.TypeSpecMap.end())
       llvm::PrintFatalError(TypeName + " not found in any standard spec.\n");
     OS << "#include <llvm-libc-types/" << getTypeHdrName(TypeName) << ".h>\n";
   }
   OS << '\n';
 
+  OS << "// NOLINTBEGIN\n";
+
   if (G.Enumerations.size() != 0)
     OS << "enum {" << '\n';
   for (const auto &Name : G.Enumerations) {
     if (G.EnumerationSpecMap.find(Name) == G.EnumerationSpecMap.end())
       llvm::PrintFatalError(
           Name + " is not listed as an enumeration in any standard spec.\n");
 
     llvm::Record *EnumerationSpec = G.EnumerationSpecMap[Name];
void writeAPIFromIndex(APIIndexer &G,
   for (const auto &Name : EntrypointNameList) {
     if (G.ObjectSpecMap.find(Name) == G.ObjectSpecMap.end())
       continue;
     llvm::Record *ObjectSpec = G.ObjectSpecMap[Name];
     auto Type = ObjectSpec->getValueAsString("Type");
     OS << "extern " << Type << " " << Name << ";\n";
   }
   OS << "__END_C_DECLS\n";
+
+  OS << "// NOLINTEND\n";
 }
 
 void writePublicAPI(llvm::raw_ostream &OS, llvm::RecordKeeper &Records) {}
 
 const char PublicAPICommand::Name[] = "public_api";
 
 void PublicAPICommand::run(llvm::raw_ostream &OS, const ArgVector &Args,
                            llvm::StringRef StdHeader,