[libc] Select FPUtils implementations via code instead of build

[gchatelet]

Summary

We want to simplify the build system and rely on code to do the implementation selection.
This is in preparation of adding a Bazel configuration (D114712).

[sivachandra]

Please wait for lntue as he is also planning some refactoring around FMA.h.

libc/src/__support/FPUtil/FEnvImpl.h

15

Nit: Any reason why prefer full paths instead of relative paths?

[gchatelet]

In D115034#3169583, @sivachandra wrote:

Please wait for lntue as he is also planning some refactoring around FMA.h.

Sure!

libc/src/__support/FPUtil/FEnvImpl.h

15

Either is fine, I just aimed for consistency. I can do relative everywhere if you prefer.

[lntue]

You can go ahead with updating FMA.h. I can merge after your submission.

[gchatelet]

• Use relative path for includes

[gchatelet]

In D115034#3169617, @lntue wrote:

You can go ahead with updating FMA.h. I can merge after your submission.

SGTM. I've used relative paths for the includes and I'll wait for the builder to go green before submitting.

libc/src/__support/FPUtil/CMakeLists.txt

-if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
-  set(LONG_DOUBLE_HDR LongDoubleBitsX86.h)
-else()
-  set(LONG_DOUBLE_HDR)
-endif()
-
-if(EXISTS ${LIBC_TARGET_ARCHITECTURE})
-  set(FENV_IMPL ${LIBC_TARGET_ARCHITECTURE}/FEnvImpl.h)
-else()
-  set(FENV_IMPL DummyFEnvImpl.h)
-endif()
-
 add_header_library(
   fputil
   HDRS
-    ${LONG_DOUBLE_HDR}
-    ${FENV_IMPL}
+    FEnvImpl.h
     BasicOperations.h
     DivisionAndRemainderOperations.h
     FEnvUtils.h
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h

libc/src/__support/FPUtil/FEnvImpl.h

-//===-- Dummy floating point environment manipulation functins --*- C++ -*-===//
+//===-- Floating point environment manipulation functions -------*- 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_DUMMY_FENVIMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_H
 
+#include "src/__support/architectures.h"
+
+#if defined(LLVM_LIBC_ARCH_AARCH64)
+#include "aarch64/FEnvImpl.h"
+#elif defined(LLVM_LIBC_ARCH_X86)
+#include "x86_64/FEnvImpl.h"
+#else
 #include <fenv.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 // All dummy functions silently succeed.
 

 static inline int setRound(int) { return 0; }
 
 static inline int getEnv(fenv_t *) { return 0; }
 
 static inline int setEnv(const fenv_t *) { return 0; }
 
 } // namespace fputil
 } // namespace __llvm_libc
+#endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_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"
 
 #if defined(LLVM_LIBC_ARCH_X86_64)
 #include "x86_64/FMA.h"
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
 #include "aarch64/FMA.h"
 #else
 #include "generic/FMA.h"
+#include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 // We have a generic implementation available only for single precision fma as
 // we restrict it to float values for now.
 template <typename T>
 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,

libc/src/__support/FPUtil/FPBits.h

static T buildNaN(UIntType v) {
     return T(bits);
   }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
-#include "src/__support/FPUtil/LongDoubleBitsX86.h"
+#include "x86_64/LongDoubleBits.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/__support/FPUtil/ManipulationFunctions.h

static inline T nextafter(T from, T to) {
   return *reinterpret_cast<T *>(&intVal);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
-#include "NextAfterLongDoubleX86.h"
+#include "x86_64/NextAfterLongDouble.h"
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/src/__support/FPUtil/Sqrt.h

if (bits.isInfOrNaN()) {
     return *reinterpret_cast<T *>(&y);
   }
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
-#include "SqrtLongDoubleX86.h"
+#include "x86_64/SqrtLongDouble.h"
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_H

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

 //===-- aarch64 floating point env manipulation functions -------*- 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_AARCH64_FENVIMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H
 
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_AARCH64)
+#error "Invalid include"
+#endif
+
 #include <arm_acle.h>
 #include <fenv.h>
 #include <stdint.h>
 
 #include "src/__support/FPUtil/FPBits.h"
 
 namespace __llvm_libc {
 namespace fputil {

libc/src/__support/FPUtil/aarch64/FMA.h

 //===-- Aarch64 implementations of the fma function -------------*- 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_AARCH64_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H
 
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_AARCH64)
+#error "Invalid include"
+#endif
+
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
 cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, T z) {
   float result;

libc/src/__support/FPUtil/x86_64/FEnvImpl.h

 //===-- x86_64 floating point env manipulation functions --------*- 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_X86_64_FENVIMPL_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H
 
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_X86)
+#error "Invalid include"
+#endif
+
 #include <fenv.h>
 #include <stdint.h>
 
 #include "src/__support/sanitizer.h"
 
 namespace __llvm_libc {
 namespace fputil {
 

libc/src/__support/FPUtil/x86_64/FMA.h

 //===-- x86_64 implementations of the fma function --------------*- 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_X86_64_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H
 
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_X86)
+#error "Invalid include"
+#endif
+
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T>
 static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
                                                                      T z) {

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 //===-- Bit representation of x86 long double numbers -----------*- 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_LONG_DOUBLE_BITS_X86_H
-#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_LONG_DOUBLE_BITS_X86_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
+#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 
-#include "FPBits.h"
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_X86)
+#error "Invalid include"
+#endif
+
+#include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <unsigned Width> struct Padding;
 

 
 static_assert(
     sizeof(FPBits<long double>) == sizeof(long double),
     "Internal long double representation does not match the machine format.");
 
 } // namespace fputil
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_LONG_DOUBLE_BITS_X86_H
+#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H

libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h

 //===-- nextafter implementation for x86 long double numbers ----*- 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_NEXT_AFTER_LONG_DOUBLE_X86_H
-#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H
+#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H
 
-#include "FPBits.h"
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_X86)
+#error "Invalid include"
+#endif
+
+#include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 static inline long double nextafter(long double from, long double to) {
   using FPBits = FPBits<long double>;
static inline long double nextafter(long double from, long double to) {
 
   return *reinterpret_cast<long double *>(&intVal);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H
+#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H

libc/src/__support/FPUtil/x86_64/SqrtLongDouble.h

 //===-- Square root of x86 long double numbers ------------------*- 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_SQRT_LONG_DOUBLE_X86_H
-#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H
+#ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_LONG_DOUBLE_H
+#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_LONG_DOUBLE_H
+
+#include "src/__support/architectures.h"
+
+#if !defined(LLVM_LIBC_ARCH_X86)
+#error "Invalid include"
+#endif
 
 #include "FPBits.h"
 #include "Sqrt.h"
 
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
if (bits.isInfOrNaN()) {
 
     return out;
   }
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H
+#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_LONG_DOUBLE_H