[libc] Fix definition and use of LIBC_INLINE macro

[mcgrathr]

Summary

LIBC_INLINE was doubly defined in two headers. Define it only in
one place. Also update a few uses to make sure it's always placed
where a function attribute is valid and is used consistently on
every declaration of the same function in case the attributes used
in its definition must match on declarations and definitions.

libc/src/__support/endian.h

 // counterpart.
 // We use explicit template specialization:
 // - to prevent accidental integer promotion.
 // - to prevent fallback in (unlikely) case of middle-endianness.
 
 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);
+  template <typename T> LIBC_INLINE static T to_big_endian(T value);
+  template <typename T> LIBC_INLINE static T to_little_endian(T value);
 };
 
 // Little Endian specializations
 template <>
 template <>
 LIBC_INLINE uint8_t
 Endian<__ORDER_LITTLE_ENDIAN__>::to_big_endian<uint8_t>(uint8_t v) {
   return v;

libc/src/__support/macros/config.h

 //===-- Portable attributes -------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 // This header file defines a set of macros for checking the presence of
 // important compiler and platform features. Such macros can be used to
 // produce portable code by parameterizing compilation based on the presence or
 // lack of a given feature.
 
 #ifndef LLVM_LIBC_SUPPORT_MACROS_CONFIG_H
 #define LLVM_LIBC_SUPPORT_MACROS_CONFIG_H
 
-#define LIBC_INLINE inline
-
 // LIBC_HAS_BUILTIN()
 //
 // Checks whether the compiler supports a Clang Feature Checking Macro, and if
 // so, checks whether it supports the provided builtin function "x" where x
 // is one of the functions noted in
 // https://clang.llvm.org/docs/LanguageExtensions.html
 //
 // Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.

libc/src/__support/macros/optimization.h

 //===-- Portable optimization macros ----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 // This header file defines portable macros for performance optimization.
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_MACROS_OPTIMIZATION_H
 #define LLVM_LIBC_SRC_SUPPORT_MACROS_OPTIMIZATION_H
 
+#include "src/__support/macros/attributes.h"          // LIBC_INLINE
 #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 */