[libc] Add more robust compile time architecture detection

[gchatelet]

Summary

We may want to restrict the detected platforms to only x86_64 and aarch64.
There are still custom detection in api.td but I don't think we can handle these:

• config/linux/api.td:205
• config/linux/api.td:199

[michaelrj]

libc/src/__support/architectures.h

38–52

I don't think we actually support these architectures yet, do we need macros for them?

[sivachandra]

Thanks for the nice cleanup.

libc/src/__support/architectures.h

38–52

I will leave it up to @gchatelet as to what he thinks about this. My personal opinion - no harm having these macros for the sake of completeness even if unused.

[gchatelet]

libc/src/__support/architectures.h

38–52

Yes we don't support them for now. Since it may confuse people into thinking they are officially supported I will remove them.
Note that these macros are fetched almost verbatim from Google's cpu_features (a side project of mine) so it's easy to fetch them back if needed.

[michaelrj]

libc/src/__support/architectures.h

38–52

SGTM

[gchatelet]

• Remove unsupported architectures

[gchatelet]

• Remove unsupported architectures

[gchatelet]

This patch broke the build so I've reverted it. I'll resubmit when it's fixed - and after the weekend :)

[gchatelet]

• Fix includes

[gchatelet]

Builders seems to be happy so I'll resubmit this patch.

libc/src/__support/CMakeLists.txt

 add_subdirectory(CPP)
 
 add_header_library(
   common
   HDRS
+    architectures.h
     common.h
     endian.h
     sanitizer.h
 )
 
 add_header_library(
   ctype_utils
   HDRS

libc/src/__support/FPUtil/FEnvUtils.h

 //===-- Utilities for manipulating floating point environment ---*- 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_FPUTIL_FENVUTILS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVUTILS_H
 
-#ifdef __x86_64__
+#include "src/__support/architectures.h"
+
+#if defined(LLVM_LIBC_ARCH_X86_64)
 #include "x86_64/FEnvImpl.h"
-#elif defined(__aarch64__)
+#elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/FEnvImpl.h"
 #else
 #include "DummyFEnvImpl.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVUTILS_H

libc/src/__support/FPUtil/FMA.h

 //===-- Common header for FMA implementations -------------------*- 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_FPUTIL_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H
 
 #include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/architectures.h"
 
-#ifdef __x86_64__
+#if defined(LLVM_LIBC_ARCH_X86_64)
 #include "x86_64/FMA.h"
-#elif defined(__aarch64__)
+#elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/FMA.h"
 #else
 #include "generic/FMA.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 // We have a generic implementation available only for single precision fma as

libc/src/__support/FPUtil/PlatformDefs.h

 //===-- Platform specific macro definitions ---------------------*- 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_FPUTIL_PLATFORM_DEFS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H
 
-#if defined(__x86_64__) || defined(__i386__)
+#include "src/__support/architectures.h"
+
+#if defined(LLVM_LIBC_ARCH_X86)
 #define X87_FPU
 #endif
 
 #if defined(_WIN32)
 #define LONG_DOUBLE_IS_DOUBLE
 #endif
 
 #if !defined(LONG_DOUBLE_IS_DOUBLE) && defined(X87_FPU)
 #define SPECIAL_X86_LONG_DOUBLE
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H

libc/src/__support/FPUtil/PolyEval.h

 //===-- Common header for PolyEval implementations --------------*- 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_FPUTIL_POLYEVAL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H
 
 #include "src/__support/CPP/TypeTraits.h"
+#include "src/__support/architectures.h"
 
 // Evaluate polynomial using Horner's Scheme:
 // With polyeval(x, a_0, a_1, ..., a_n) = a_n * x^n + ... + a_1 * x + a_0, we
 // evaluated it as:  a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
 // We will use fma instructions if available.
 // Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
 //   polyeval( x, 4.0, 3.0, 2.0, 1.0 )
 
-#if defined(__x86_64__) || defined(__aarch64__)
+#if defined(LLVM_LIBC_ARCH_X86_64) || defined(LLVM_LIBC_ARCH_AARCH64)
 #include "FMA.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> static inline T polyeval(T x, T a0) { return a0; }
 
 template <typename T, typename... Ts>

libc/src/__support/architectures.h

+//===-- Compile time architecture detection -------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__pnacl__) || defined(__CLR_VER)
+#define LLVM_LIBC_ARCH_VM
+#endif
+
+#if (defined(_M_IX86) || defined(__i386__)) && !defined(LLVM_LIBC_ARCH_VM)
+#define LLVM_LIBC_ARCH_X86_32
+#endif
+
+#if (defined(_M_X64) || defined(__x86_64__)) && !defined(LLVM_LIBC_ARCH_VM)
+#define LLVM_LIBC_ARCH_X86_64
+#endif
+
+#if defined(LLVM_LIBC_ARCH_X86_32) || defined(LLVM_LIBC_ARCH_X86_64)
+#define LLVM_LIBC_ARCH_X86
+#endif
+
+#if (defined(__arm__) || defined(_M_ARM))
+#define LLVM_LIBC_ARCH_ARM
+#endif
+
+#if defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64)
+#define LLVM_LIBC_ARCH_AARCH64
+#endif
+
+#if (defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_ARM))
+#define LLVM_LIBC_ARCH_ANY_ARM
+#endif

libc/src/string/memcmp.cpp

 //===-- Implementation of memcmp ------------------------------------------===//
 //
 // 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/memcmp.h"
+#include "src/__support/architectures.h"
 #include "src/__support/common.h"
 #include "src/string/memory_utils/elements.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 static int memcmp_impl(const char *lhs, const char *rhs, size_t count) {
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(LLVM_LIBC_ARCH_X86)
   using namespace ::__llvm_libc::x86;
 #else
   using namespace ::__llvm_libc::scalar;
 #endif
 
   if (count == 0)
     return 0;
   if (count == 1)

libc/src/string/memory_utils/elements_aarch64.h

 //===-- Elementary operations for aarch64 --------------------------------===//
 //
 // 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_ELEMENTS_AARCH64_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_AARCH64_H
 
-#if defined(__arm__) || defined(__aarch64__)
+#include "src/__support/architectures.h"
+
+#if defined(LLVM_LIBC_ARCH_AARCH64)
 
 #include <src/string/memory_utils/elements.h>
 #include <stddef.h> // size_t
 #include <stdint.h> // uint8_t, uint16_t, uint32_t, uint64_t
 
 #ifdef __ARM_NEON
 #include <arm_neon.h>
 #endif

 using _32 = N32;
 #else
 using _32 = __llvm_libc::scalar::_32;
 #endif // __ARM_NEON
 
 } // namespace aarch64
 } // namespace __llvm_libc
 
-#endif // defined(__arm__) || defined(__aarch64__)
+#endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_AARCH64_H

libc/src/string/memory_utils/elements_x86.h

 //===-- Elementary operations for x86 -------------------------------------===//
 //
 // 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_ELEMENTS_X86_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_X86_H
 
-#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) ||            \
-    defined(_M_X64)
+#include "src/__support/architectures.h"
+
+#if defined(LLVM_LIBC_ARCH_X86)
 
 #include <stddef.h> // size_t
 #include <stdint.h> // uint8_t, uint16_t, uint32_t, uint64_t
 
 #ifdef __SSE2__
 #include <immintrin.h>
 #endif //  __SSE2__
 
struct Accelerator {
   static void Copy(char *dst, const char *src, size_t count) {
     asm volatile("rep movsb" : "+D"(dst), "+S"(src), "+c"(count) : : "memory");
   }
 };
 
 } // namespace x86
 } // namespace __llvm_libc
 
-#endif // defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) ||
-       // defined(_M_X64)
+#endif // defined(LLVM_LIBC_ARCH_X86)
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_X86_H

libc/src/string/memory_utils/memset_utils.h

 //===-- Memset 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_STRING_MEMORY_UTILS_MEMSET_UTILS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_UTILS_H
 
+#include "src/__support/architectures.h"
 #include "src/string/memory_utils/elements.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 // A general purpose implementation assuming cheap unaligned writes for sizes:

 // more hot code to fit in the iL1 cache.
 //
 // Above 128 we have to use conditionals since we don't know the upper bound in
 // advance. SetAlignedBlocks<64> may waste up to 63 Bytes, SetAlignedBlocks<32>
 // may waste up to 31 Bytes. Benchmarks showed that SetAlignedBlocks<64> was not
 // superior for sizes that mattered.
 inline static void GeneralPurposeMemset(char *dst, unsigned char value,
                                         size_t count) {
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(LLVM_LIBC_ARCH_X86)
   using namespace ::__llvm_libc::x86;
 #else
   using namespace ::__llvm_libc::scalar;
 #endif
 
   if (count == 0)
     return;
   if (count == 1)

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/architectures.h"
+
 // Cache line sizes for ARM: These values are not strictly correct since
 // cache line sizes depend on implementations, not architectures.  There
 // are even implementations with cache line sizes configurable at boot
 // time.
-#if defined(__aarch64__)
-#define LLVM_LIBC_CACHELINE_SIZE 64
-#elif defined(__ARM_ARCH_5T__)
-#define LLVM_LIBC_CACHELINE_SIZE 32
-#elif defined(__ARM_ARCH_7A__)
-#define LLVM_LIBC_CACHELINE_SIZE 64
-#elif defined(__PPC64__)
-#define LLVM_LIBC_CACHELINE_SIZE 128
-#elif defined(__i386__) || defined(__x86_64__)
+#if defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_X86)
 #define LLVM_LIBC_CACHELINE_SIZE 64
 #else
 #error "Unsupported platform for memory functions."
 #endif
 
 #include <stddef.h> // size_t
 #include <stdint.h> // intptr_t / uintptr_t
 

libc/test/src/fenv/enabled_exceptions_test.cpp

 //===-- Unittests for feraiseexcept with exceptions enabled ---------------===//
 //
 // 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/fenv/feclearexcept.h"
 #include "src/fenv/feraiseexcept.h"
 #include "src/fenv/fetestexcept.h"
 
 #include "src/__support/FPUtil/FEnvUtils.h"
+#include "src/__support/architectures.h"
 #include "utils/UnitTest/FPExceptMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 // This test enables an exception and verifies that raising that exception
 // triggers SIGFPE.
 TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
-#ifdef __aarch64__
+#if defined(LLVM_LIBC_ARCH_AARCH64)
   // Few aarch64 HW implementations do not trap exceptions. We skip this test
   // completely on such HW.
   //
   // Whether HW supports trapping exceptions or not is deduced by enabling an
   // exception and reading back to see if the exception got enabled. If the
   // exception did not get enabled, then it means that the HW does not support
   // trapping exceptions.
   __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
   __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
   if (__llvm_libc::fputil::getExcept() == 0)
     return;
-#endif
+#endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
   // TODO: Install a floating point exception handler and verify that the
   // the expected exception was raised. One will have to longjmp back from
   // that exception handler, so such a testing can be done after we have
   // longjmp implemented.
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};

libc/test/src/fenv/feenableexcept_test.cpp

 //===-- Unittests for feenableexcept  -------------------------------------===//
 //
 // 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/fenv/fedisableexcept.h"
 #include "src/fenv/feenableexcept.h"
+
+#include "src/__support/architectures.h"
+#include "src/fenv/fedisableexcept.h"
 #include "src/fenv/fegetexcept.h"
 
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFEnvTest, EnableTest) {
-#ifdef __aarch64__
+#if defined(LLVM_LIBC_ARCH_AARCH64)
   // Few aarch64 HW implementations do not trap exceptions. We skip this test
   // completely on such HW.
   //
   // Whether HW supports trapping exceptions or not is deduced by enabling an
   // exception and reading back to see if the exception got enabled. If the
   // exception did not get enabled, then it means that the HW does not support
   // trapping exceptions.
   __llvm_libc::fedisableexcept(FE_ALL_EXCEPT);
   __llvm_libc::feenableexcept(FE_DIVBYZERO);
   if (__llvm_libc::fegetexcept() == 0)
     return;
-#endif
+#endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
   __llvm_libc::fedisableexcept(FE_ALL_EXCEPT);
   ASSERT_EQ(0, __llvm_libc::fegetexcept());
 
   for (int e : excepts) {
     __llvm_libc::feenableexcept(e);

libc/test/src/fenv/feholdexcept_test.cpp

 //===-- Unittests for feholdexcept with exceptions enabled ----------------===//
 //
 // 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/fenv/feholdexcept.h"
 
 #include "src/__support/FPUtil/FEnvUtils.h"
+#include "src/__support/architectures.h"
 #include "utils/UnitTest/FPExceptMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
-#ifdef __aarch64__
+#if defined(LLVM_LIBC_ARCH_AARCH64)
   // Few aarch64 HW implementations do not trap exceptions. We skip this test
   // completely on such HW.
   //
   // Whether HW supports trapping exceptions or not is deduced by enabling an
   // exception and reading back to see if the exception got enabled. If the
   // exception did not get enabled, then it means that the HW does not support
   // trapping exceptions.
   __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
   __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
   if (__llvm_libc::fputil::getExcept() == 0)
     return;
-#endif
+#endif // defined(LLVM_LIBC_ARCH_AARCH64)
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
     fenv_t env;
     __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
     __llvm_libc::fputil::enableExcept(e);

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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 "MPFRUtils.h"
 
 #include "src/__support/CPP/StringView.h"
 #include "src/__support/FPUtil/FPBits.h"
-#include "utils/UnitTest/FPMatcher.h"
+#include "src/__support/FPUtil/TestHelpers.h"
+#include "src/__support/architectures.h"
 
 #include <cmath>
 #include <memory>
 #include <stdint.h>
 #include <string>
 
 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third

 template <> struct Precision<float> {
   static constexpr unsigned int value = 24;
 };
 
 template <> struct Precision<double> {
   static constexpr unsigned int value = 53;
 };
 
-#if !(defined(__x86_64__) || defined(__i386__))
+#if !(defined(LLVM_LIBC_ARCH_X86))
 template <> struct Precision<long double> {
   static constexpr unsigned int value = 64;
 };
 #else
 template <> struct Precision<long double> {
   static constexpr unsigned int value = 113;
 };
 #endif
explicit MPFRNumber(XType x, int precision = 128) : mpfrPrecision(precision) {
     mpfr_set_sj(value, x, MPFR_RNDN);
   }
 
   MPFRNumber(const MPFRNumber &other) : mpfrPrecision(other.mpfrPrecision) {
     mpfr_init2(value, mpfrPrecision);
     mpfr_set(value, other.value, MPFR_RNDN);
   }
 
-  ~MPFRNumber() {
-    mpfr_clear(value);
-  }
+  ~MPFRNumber() { mpfr_clear(value); }
 
   MPFRNumber &operator=(const MPFRNumber &rhs) {
     mpfrPrecision = rhs.mpfrPrecision;
     mpfr_set(value, rhs.value, MPFR_RNDN);
     return *this;
   }
 
   MPFRNumber abs() const {