[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

18

We may want to put this into its own header_library.

[sivachandra]

libc/src/__support/CMakeLists.txt

18

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
-  HDRS
-    builtin_wrappers.h
-  DEPENDS
-    .named_pair
-    libc.src.__support.CPP.type_traits
-)
-
-add_header_library(
   common
   HDRS
+    compilers.h
     architectures.h
     common.h
     endian.h
     sanitizer.h
 )
 
 add_header_library(
+  builtin_wrappers
+  HDRS
+    builtin_wrappers.h
+  DEPENDS
+    .named_pair
+    libc.src.__support.CPP.type_traits
+    libc.src.__support.common
+)
+
+add_header_library(
   ctype_utils
   HDRS
     ctype_utils.h
 )
 
 add_header_library(
   str_to_integer
   HDRS

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/compilers.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/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/compilers.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/compilers.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_COMPILERS_H
+#define LLVM_LIBC_SUPPORT_COMPILERS_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_COMPILERS_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/compilers.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/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/compilers.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/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/compilers.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

 
 ############################## Support libraries #############################
 
 cc_library(
     name = "__support_common",
     hdrs = [
         "src/__support/architectures.h",
         "src/__support/common.h",
+        "src/__support/compilers.h",
         "src/__support/endian.h",
         "src/__support/sanitizer.h",
     ],
 )
 
 cc_library(
     name = "__support_cpp_array",
     hdrs = ["src/__support/CPP/array.h"],
cc_library(
     hdrs = ["src/__support/named_pair.h"],
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_builtin_wrappers",
     hdrs = ["src/__support/builtin_wrappers.h"],
     deps = [
+        ":__support_common",
         ":__support_cpp_type_traits",
         ":__support_named_pair",
         ":libc_root",
     ],
 )
 
 cc_library(
     name = "__support_fputil_division_and_remainder_operations",