[libc] Add compiler, builtin and feature detection

[gchatelet]

Summary

This is a first step to support GCC. This patch adds support for builtin and feature detection.

[gchatelet]

• Fix typo

[gchatelet]

libc/src/__support/CMakeLists.txt

32

We may want to put this into its own header_library.

[sivachandra]

libc/src/__support/CMakeLists.txt

32

Agreed. Also, may be a name like compiler_features.h?

[gchatelet]

• Address comments and rebase

libc/src/__support/CMakeLists.txt

 add_subdirectory(CPP)
 
 add_header_library(
   blockstore
   HDRS
     blockstore.h
 )
 
 add_header_library(
   named_pair
   HDRS
     named_pair.h
 )
 
 add_header_library(
-  builtin_wrappers
+  compiler_features
   HDRS
-    builtin_wrappers.h
+    compiler_features.h
+)
+
+add_header_library(
+  sanitizer
+  HDRS
+    sanitizer.h
   DEPENDS
-    .named_pair
-    libc.src.__support.CPP.type_traits
+    libc.src.__support.compiler_features
 )
 
 add_header_library(
   common
   HDRS
     architectures.h
     common.h
     endian.h
-    sanitizer.h
+)
+
+add_header_library(
+  builtin_wrappers
+  HDRS
+    builtin_wrappers.h
+  DEPENDS
+    .named_pair
+    libc.src.__support.common
+    libc.src.__support.compiler_features
+    libc.src.__support.CPP.type_traits
 )
 
 add_header_library(
   error_or
   HDRS
     error_or.h
   DEPENDS
     libc.src.__support.CPP.expected

libc/src/__support/CPP/CMakeLists.txt

 add_header_library(
   array
   HDRS
     array.h
 )
 
 add_header_library(
   bit
   HDRS
     bit.h
+  DEPENDS
+    libc.src.__support.compiler_features
 )
 
 add_header_library(
   bitset
   HDRS
     bitset.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/compiler_features.h"
+
 namespace __llvm_libc::cpp {
 
-#if defined __has_builtin
-#if __has_builtin(__builtin_bit_cast)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_bit_cast)
 #define LLVM_LIBC_HAS_BUILTIN_BIT_CAST
 #endif
-#endif
 
-#if defined __has_builtin
-#if __has_builtin(__builtin_memcpy_inline)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_memcpy_inline)
 #define LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
 #endif
-#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) {
   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

libc/src/__support/FPUtil/CMakeLists.txt

 add_header_library(
   fenv_impl
   HDRS
     FEnvImpl.h
   DEPENDS
     libc.include.fenv
     libc.src.__support.common
+    libc.src.__support.compiler_features
 )
 
 add_header_library(
   platform_defs
   HDRS
     PlatformDefs.h
   DEPENDS
     libc.src.__support.common

libc/src/__support/builtin_wrappers.h

 //===--Convenient template for builtins -------------------------*- C++ -*-===//
 //             (Count Lead Zeroes) and (Count Trailing Zeros)
 //
 // 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_BUILTIN_WRAPPERS_H
 #define LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H
 
 #include "named_pair.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/compiler_features.h"
 
 namespace __llvm_libc {
 
 // The following overloads are matched based on what is accepted by
 // __builtin_clz/ctz* rather than using the exactly-sized aliases from stdint.h.
 // This way, we can avoid making any assumptions about integer sizes and let the
 // compiler match for us.
 namespace __internal {
inline constexpr cpp::enable_if_t<
     cpp::is_integral_v<T> && cpp::is_unsigned_v<T>, SumCarry<T>>
 add_with_carry(T a, T b, T carry_in) {
   T tmp = a + carry_in;
   T sum = b + tmp;
   T carry_out = (sum < b) || (tmp < a);
   return {sum, carry_out};
 }
 
-#if __has_builtin(__builtin_addc)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_addc)
 // https://clang.llvm.org/docs/LanguageExtensions.html#multiprecision-arithmetic-builtins
 
 template <>
 inline SumCarry<unsigned char>
 add_with_carry<unsigned char>(unsigned char a, unsigned char b,
                               unsigned char carry_in) {
   SumCarry<unsigned char> result{0, 0};
   result.sum = __builtin_addcb(a, b, carry_in, &result.carry);

 inline SumCarry<unsigned long long>
 add_with_carry<unsigned long long>(unsigned long long a, unsigned long long b,
                                    unsigned long long carry_in) {
   SumCarry<unsigned long long> result{0, 0};
   result.sum = __builtin_addcll(a, b, carry_in, &result.carry);
   return result;
 }
 
-#endif // __has_builtin(__builtin_addc)
+#endif // LLVM_LIBC_HAS_BUILTIN(__builtin_addc)
 
 // Subtract with borrow
 DEFINE_NAMED_PAIR_TEMPLATE(DiffBorrow, diff, borrow);
 
 template <typename T>
 inline constexpr cpp::enable_if_t<
     cpp::is_integral_v<T> && cpp::is_unsigned_v<T>, DiffBorrow<T>>
 sub_with_borrow(T a, T b, T borrow_in) {
   T tmp = a - b;
   T diff = tmp - borrow_in;
   T borrow_out = (diff > tmp) || (tmp > a);
   return {diff, borrow_out};
 }
 
-#if __has_builtin(__builtin_subc)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_subc)
 // https://clang.llvm.org/docs/LanguageExtensions.html#multiprecision-arithmetic-builtins
 
 template <>
 inline DiffBorrow<unsigned char>
 sub_with_borrow<unsigned char>(unsigned char a, unsigned char b,
                                unsigned char borrow_in) {
   DiffBorrow<unsigned char> result{0, 0};
   result.diff = __builtin_subcb(a, b, borrow_in, &result.borrow);

 inline DiffBorrow<unsigned long long>
 sub_with_borrow<unsigned long long>(unsigned long long a, unsigned long long b,
                                     unsigned long long borrow_in) {
   DiffBorrow<unsigned long long> result{0, 0};
   result.diff = __builtin_subcll(a, b, borrow_in, &result.borrow);
   return result;
 }
 
-#endif // __has_builtin(__builtin_subc)
+#endif // LLVM_LIBC_HAS_BUILTIN(__builtin_subc)
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H

libc/src/__support/compiler_features.h

+//===-- Compile time compiler detection -------------------------*- 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_COMPILER_FEATURES_H
+#define LLVM_LIBC_SUPPORT_COMPILER_FEATURES_H
+
+#if defined(__clang__)
+#define LLVM_LIBC_COMPILER_CLANG
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#define LLVM_LIBC_COMPILER_GCC
+#endif
+
+#if defined(_MSC_VER)
+#define LLVM_LIBC_COMPILER_MSC
+#endif
+
+// Compiler builtin-detection.
+// clang.llvm.org/docs/LanguageExtensions.html#has-builtin
+#if defined(LLVM_LIBC_COMPILER_CLANG) ||                                       \
+    (defined(LLVM_LIBC_COMPILER_GCC) && (__GNUC__ >= 10))
+#define LLVM_LIBC_HAS_BUILTIN(BUILTIN) __has_builtin(BUILTIN)
+#else
+#define LLVM_LIBC_HAS_BUILTIN(BUILTIN) 0
+#endif
+
+// Compiler feature-detection.
+// clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension
+#if defined(LLVM_LIBC_COMPILER_CLANG)
+#define LLVM_LIBC_HAS_FEATURE(FEATURE) __has_feature(FEATURE)
+#else
+#define LLVM_LIBC_HAS_FEATURE(FEATURE) 0
+#endif
+
+#endif // LLVM_LIBC_SUPPORT_COMPILER_FEATURES_H

libc/src/__support/sanitizer.h

 //===-- Convenient sanitizer 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_SANITIZER_H
 #define LLVM_LIBC_SRC_SUPPORT_SANITIZER_H
 
-#ifdef __has_feature
-#define LLVM_LIBC_HAVE_FEATURE(f) __has_feature(f)
-#else
-#define LLVM_LIBC_HAVE_FEATURE(f) 0
-#endif
+#include "src/__support/compiler_features.h"
 
 // MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of
 // a compiler instrumentation module and a run-time library.
 #ifdef LLVM_LIBC_HAVE_MEMORY_SANITIZER
 #error "LLVM_LIBC_HAVE_MEMORY_SANITIZER cannot be directly set."
 #elif defined(MEMORY_SANITIZER)
 // The MEMORY_SANITIZER macro is deprecated but we will continue to honor it
 // for now.
 #define LLVM_LIBC_HAVE_MEMORY_SANITIZER 1
 #elif defined(__SANITIZE_MEMORY__)
 #define LLVM_LIBC_HAVE_MEMORY_SANITIZER 1
-#elif !defined(__native_client__) && LLVM_LIBC_HAVE_FEATURE(memory_sanitizer)
+#elif !defined(__native_client__) && LLVM_LIBC_HAS_FEATURE(memory_sanitizer)
 #define LLVM_LIBC_HAVE_MEMORY_SANITIZER 1
 #endif
 
 // AddressSanitizer (ASan) is a fast memory error detector.
 #ifdef LLVM_LIBC_HAVE_ADDRESS_SANITIZER
 #error "LLVM_LIBC_HAVE_ADDRESS_SANITIZER cannot be directly set."
 #elif defined(ADDRESS_SANITIZER)
 // The ADDRESS_SANITIZER macro is deprecated but we will continue to honor it
 // for now.
 #define LLVM_LIBC_HAVE_ADDRESS_SANITIZER 1
 #elif defined(__SANITIZE_ADDRESS__)
 #define LLVM_LIBC_HAVE_ADDRESS_SANITIZER 1
-#elif LLVM_LIBC_HAVE_FEATURE(address_sanitizer)
+#elif LLVM_LIBC_HAS_FEATURE(address_sanitizer)
 #define LLVM_LIBC_HAVE_ADDRESS_SANITIZER 1
 #endif
 
 // HWAddressSanitizer (HWASan) is a fast, low memory overhead error detector.
 #ifdef LLVM_LIBC_HAVE_HWADDRESS_SANITIZER
 #error "LLVM_LIBC_HAVE_HWADDRESS_SANITIZER cannot be directly set."
-#elif LLVM_LIBC_HAVE_FEATURE(hwaddress_sanitizer)
+#elif LLVM_LIBC_HAS_FEATURE(hwaddress_sanitizer)
 #define LLVM_LIBC_HAVE_HWADDRESS_SANITIZER 1
 #endif
 
 #if LLVM_LIBC_HAVE_MEMORY_SANITIZER
 #include <sanitizer/msan_interface.h>
 #define SANITIZER_MEMORY_INITIALIZED(addr, size) __msan_unpoison(addr, size)
 #else
 #define SANITIZER_MEMORY_INITIALIZED(ptr, size)
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_SANITIZER_H

libc/src/string/memory_utils/CMakeLists.txt

HDRS
     memset_implementations.h
     op_aarch64.h
     op_builtin.h
     op_generic.h
     op_x86.h
     utils.h
   DEPS
     libc.src.__support.common
+    libc.src.__support.compiler_features
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.cstddef
     libc.src.__support.CPP.type_traits
 )
 
 add_header_library(
   memcpy_implementation
   HDRS

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/compiler_features.h"
 
 #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>
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) {
   return reinterpret_cast<T *>(__builtin_assume_aligned(ptr, alignment));
 }
 
-#if defined __has_builtin
-#if __has_builtin(__builtin_memcpy_inline)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_memcpy_inline)
 #define LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
 #endif
-#endif
 
-#if defined __has_builtin
-#if __has_builtin(__builtin_memset_inline)
+#if LLVM_LIBC_HAS_BUILTIN(__builtin_memset_inline)
 #define LLVM_LIBC_HAS_BUILTIN_MEMSET_INLINE
 #endif
-#endif
 
 // Performs a constant count copy.
 template <size_t Size>
 static inline void memcpy_inline(void *__restrict dst,
                                  const void *__restrict src) {
 #ifdef LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
   __builtin_memcpy_inline(dst, src, Size);
 #else

libc/src/string/stpcpy.cpp

 //===-- Implementation of stpcpy ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/stpcpy.h"
 #include "src/string/mempcpy.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
-#include "src/__support/sanitizer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, stpcpy,
                    (char *__restrict dest, const char *__restrict src)) {
   size_t size = internal::string_length(src) + 1;
   char *result =
       reinterpret_cast<char *>(__llvm_libc::mempcpy(dest, src, size));
 
   if (result != nullptr)
     return result - 1;
   return nullptr;
 }
 
 } // namespace __llvm_libc

libc/test/src/string/memory_utils/CMakeLists.txt

 add_libc_unittest(
   utils_test
   SUITE
     libc_string_unittests
   SRCS
     op_tests.cpp
     utils_test.cpp
   COMPILE_OPTIONS
     ${LIBC_COMPILE_OPTIONS_NATIVE}
     -ffreestanding
   DEPENDS
-    libc.src.string.memory_utils.memory_utils
+    libc.src.__support.compiler_features
     libc.src.__support.CPP.array
-    libc.src.__support.CPP.span
     libc.src.__support.CPP.cstddef
+    libc.src.__support.CPP.span
+    libc.src.string.memory_utils.memory_utils
 )

libc/test/src/string/memory_utils/memory_check_utils.h

 //===-- Utils to test conformance of mem functions ------------------------===//
 //
 // 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 LIBC_TEST_SRC_STRING_MEMORY_UTILS_MEMORY_CHECK_UTILS_H
 #define LIBC_TEST_SRC_STRING_MEMORY_UTILS_MEMORY_CHECK_UTILS_H
 
 #include "src/__support/CPP/span.h"
+#include "src/__support/compiler_features.h"
 #include "src/string/memory_utils/utils.h"
 #include <assert.h> // assert
 #include <stddef.h> // size_t
 #include <stdint.h> // uintxx_t
 #include <stdlib.h> // malloc/free
 
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#if LLVM_LIBC_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 #include <sanitizer/asan_interface.h>
 #define ASAN_POISON_MEMORY_REGION(addr, size)                                  \
   __asan_poison_memory_region((addr), (size))
 #define ASAN_UNPOISON_MEMORY_REGION(addr, size)                                \
   __asan_unpoison_memory_region((addr), (size))
 #else
 #define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
 #define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))

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

 cc_library(
     name = "libc_root",
     includes = ["."],
 )
 
 ############################## Support libraries #############################
 
 libc_support_library(
+    name = "__support_compiler_features",
+    hdrs = ["src/__support/compiler_features.h"],
+)
+
+libc_support_library(
+    name = "__support_sanitizer",
+    hdrs = ["src/__support/sanitizer.h"],
+    deps = [":__support_compiler_features"],
+)
+
+libc_support_library(
     name = "__support_common",
     hdrs = [
         "src/__support/architectures.h",
         "src/__support/common.h",
         "src/__support/endian.h",
-        "src/__support/sanitizer.h",
     ],
 )
 
 libc_support_library(
     name = "__support_cpp_array",
     hdrs = ["src/__support/CPP/array.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_cpp_bit",
     hdrs = ["src/__support/CPP/bit.h"],
-    deps = [":libc_root"],
+    deps = [
+        ":__support_compiler_features",
+        ":libc_root",
+    ],
 )
 
 libc_support_library(
     name = "__support_cpp_bitset",
     hdrs = ["src/__support/CPP/bitset.h"],
     deps = [":libc_root"],
 )
 
libc_support_library(
     hdrs = ["src/__support/named_pair.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_builtin_wrappers",
     hdrs = ["src/__support/builtin_wrappers.h"],
     deps = [
+        ":__support_common",
         ":__support_cpp_type_traits",
         ":__support_named_pair",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_division_and_remainder_operations",
libc_support_library(
     hdrs = ["src/__support/FPUtil/FEnvImpl.h"],
     textual_hdrs = [
         "src/__support/FPUtil/x86_64/FEnvImpl.h",
         "src/__support/FPUtil/aarch64/FEnvImpl.h",
         "src/__support/FPUtil/aarch64/fenv_darwin_impl.h",
     ],
     deps = [
         ":__support_common",
+        ":__support_compiler_features",
         ":__support_fputil_fp_bits",
+        ":__support_sanitizer",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_float_properties",
     hdrs = ["src/__support/FPUtil/FloatProperties.h"],
     deps = [