[libc] Switch functions to using global headers

[michaelrj]

Summary

This switches all of the files in src/string, src/math, and
test/src/math from using relative paths (e.g. #include “include/string.h”)
to global paths (e.g. #include <string.h>) to make bringing up those
functions on other platforms, such as fuchsia, easier.

[MaskRay]

This does not sound right if standard system includes are not excluded (-nostdinc)

[sivachandra]

I think Michael is trying to satisfy a Fuchsia use case which is effectively like taking sources from LLVM libc and dropping them into Fuchsia's libc. In which case, the internal paths currently used by LLVM libc will not work. After going through all the combinations in this change, I think we should probably not do this for all headers. Take threads.h for example. It has type definitions which cannot be mixed with threads.h from elsewhere. This is effectively what Fangrui is pointing out - mixing is fraught with landmines.

So, Michael, we should probably limit this to just math.h and string.h as the functions from these headers are not ABI or platform sensitive. That is, you should only replace #include "include/math.h" with #include <math.h>, and #include "include/string.h with #include <string.h> from within implementations of math and string functions only. Also, I think the current includes of include/string.h can be replaced with includes of stddef.h? If so, then may be do that instead of including the public header.

By limiting to just string.h and math.h, we are not only saying that it is OK to take sources of LLVM libc's string.h and math.h functions and drop them into another libc's source tree, we are also saying that doing the same with other functions is not OK. That doesn't mean this situation is completely fine. We need to have a more principled way of doing this, at the least add a document somewhere explaining this inconsistency. LLVM libc'c build itself is protected by the clang tidy check llvmlibc-restrict-system-libc-headers. May be, we should additionally have some check which catches inclusion of public headers in implementations of ABI sensitive functions. All of these can be taken up outside this patch.

[michaelrj]

reset the #includes for everything not in src/string and src/math

[michaelrj]

switch the tests to using the global headers to match the sources they're testing.

[sivachandra]

I will consider this experimental for now. We should follow up with a plan for a tool based build time guidance which will tell us if including the header <...> is OK.

libc/src/math/cosf.cpp

 //===-- Single-precision cos function -------------------------------------===//
 //
 // 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 "math_utils.h"
 #include "sincosf_utils.h"
 
-#include "include/math.h"
 #include "src/__support/common.h"
+#include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // Fast cosf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer

libc/src/math/exp2f.cpp

 //===-- Single-precision 2^x function -------------------------------------===//
 //
 // 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 "exp_utils.h"
 #include "math_utils.h"
 
-#include "include/math.h"
 #include "src/__support/common.h"
+#include <math.h>
 
 #include <stdint.h>
 
 #define T exp2f_data.tab
 #define C exp2f_data.poly
 #define SHIFT exp2f_data.shift_scaled
 
 namespace __llvm_libc {

libc/src/math/expf.cpp

 //===-- Single-precision e^x function -------------------------------------===//
 //
 // 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 "exp_utils.h"
 #include "math_utils.h"
 
-#include "include/math.h"
 #include "src/__support/common.h"
+#include <math.h>
 
 #include <stdint.h>
 
 #define InvLn2N exp2f_data.invln2_scaled
 #define T exp2f_data.tab
 #define C exp2f_data.poly_scaled
 #define SHIFT exp2f_data.shift
 

libc/src/math/math_utils.h

 //===-- Collection of utils for implementing math 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_MATH_MATH_UTILS_H
 #define LLVM_LIBC_SRC_MATH_MATH_UTILS_H
 
-#include "include/errno.h"
-#include "include/math.h"
 #include "src/__support/common.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "utils/CPP/TypeTraits.h"
+#include <errno.h>
+#include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 static inline uint32_t as_uint32_bits(float x) {
   return *reinterpret_cast<uint32_t *>(&x);
 }

libc/src/math/sincosf.cpp

 //===-- Single-precision sincos function ----------------------------------===//
 //
 // 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 "math_utils.h"
 #include "sincosf_utils.h"
 
-#include "include/math.h"
 #include "src/__support/common.h"
+#include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // Fast sincosf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer

libc/src/math/sinf.cpp

 //===-- Single-precision sin function -------------------------------------===//
 //
 // 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 "math_utils.h"
 #include "sincosf_utils.h"
 
-#include "include/math.h"
 #include "src/__support/common.h"
+#include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // Fast sinf implementation. Worst-case ULP is 0.5607, maximum relative
 // error is 0.5303 * 2^-23. A single-step range reduction is used for
 // small values. Large inputs have their range reduced using fast integer

libc/src/string/strcat.h

 //===-- Implementation header for strcat ------------------------*- 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_STRCAT_H
 #define LLVM_LIBC_SRC_STRING_STRCAT_H
 
-#include "include/string.h"
+#include <string.h>
 
 namespace __llvm_libc {
 
 char *strcat(char *__restrict dest, const char *__restrict src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCAT_H

libc/src/string/strcpy.h

 //===-- Implementation header for strcpy ------------------------*- 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_STRCPY_H
 #define LLVM_LIBC_SRC_STRING_STRCPY_H
 
-#include "include/string.h"
+#include <string.h>
 
 namespace __llvm_libc {
 
 char *strcpy(char *__restrict dest, const char *__restrict src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRCPY_H

libc/src/string/strlen.h

 //===-- Implementation header for strlen ------------------------*- 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_STRLEN_H
 #define LLVM_LIBC_SRC_STRING_STRLEN_H
 
-#include "include/string.h"
+#include <string.h>
 
 namespace __llvm_libc {
 
 size_t strlen(const char *src);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_STRLEN_H

libc/test/src/math/FDimTest.h

 //===-- Utility class to test different flavors of fdim ---------*- 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
 //
 //===---------------------------------------------------------------------===//
 
-#include "include/math.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 template <typename T>
 class FDimTestTemplate : public __llvm_libc::testing::Test {
 public:
   using FuncPtr = T (*)(T, T);
   using FPBits = __llvm_libc::fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
 

libc/test/src/math/ILogbTest.h

 //===-- Utility class to test different flavors of ilogb --------*- 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_TEST_SRC_MATH_ILOGBTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H
 
-#include "include/math.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <limits.h>
 
 class ILogbTest : public __llvm_libc::testing::Test {
 public:
   template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
 
   template <typename T>

libc/test/src/math/ceil_test.cpp

 //===-- Unittests for ceil ------------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/ceil.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(CeilTest, SpecialNumbers) {

libc/test/src/math/ceilf_test.cpp

 //===-- Unittests for ceilf -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/ceilf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(CeilfTest, SpecialNumbers) {

libc/test/src/math/ceill_test.cpp

 //===-- Unittests for ceill -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/ceill.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(CeillTest, SpecialNumbers) {

libc/test/src/math/copysign_test.cpp

 //===-- Unittests for copysign --------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/copysign.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(CopySignTest, SpecialNumbers) {
   EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, -1.0));
   EXPECT_FP_EQ(nan, __llvm_libc::copysign(nan, 1.0));

libc/test/src/math/copysignf_test.cpp

 //===-- Unittests for copysignf -------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/copysignf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(CopySinfTest, SpecialNumbers) {
   EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, -1.0));
   EXPECT_FP_EQ(nan, __llvm_libc::copysignf(nan, 1.0));

libc/test/src/math/copysignl_test.cpp

 //===-- Unittests for copysignl -------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/copysignl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(CopySinlTest, SpecialNumbers) {
   EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, -1.0));
   EXPECT_FP_EQ(nan, __llvm_libc::copysignl(nan, 1.0));

libc/test/src/math/cosf_test.cpp

 //===-- Unittests for cosf ------------------------------------------------===//
 //
 // 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 "include/errno.h"
-#include "include/math.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/math/cosf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/CPP/Array.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <stdint.h>
 
 using __llvm_libc::fputil::isNegativeQuietNaN;
 using __llvm_libc::fputil::isQuietNaN;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 

libc/test/src/math/exp2f_test.cpp

 //===-- Unittests for exp2f -----------------------------------------------===//
 //
 // 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 "include/errno.h"
-#include "include/math.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/math/exp2f.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <stdint.h>
 
 using __llvm_libc::fputil::isNegativeQuietNaN;
 using __llvm_libc::fputil::isQuietNaN;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 

libc/test/src/math/expf_test.cpp

 //===-- Unittests for expf ------------------------------------------------===//
 //
 // 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 "include/errno.h"
-#include "include/math.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/math/expf.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <stdint.h>
 
 using __llvm_libc::fputil::isNegativeQuietNaN;
 using __llvm_libc::fputil::isQuietNaN;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 

libc/test/src/math/fabs_test.cpp

 //===-- Unittests for fabs ------------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fabs.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabsTest, SpecialNumbers) {

libc/test/src/math/fabsf_test.cpp

 //===-- Unittests for fabsf -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fabsf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabsfTest, SpecialNumbers) {

libc/test/src/math/fabsl_test.cpp

 //===-- Unittests for fabsl -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fabsl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FabslTest, SpecialNumbers) {

libc/test/src/math/fdim_test.cpp

 //===-- Unittests for fdim ------------------------------------------------===//
 //
 // 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 "FDimTest.h"
 
-#include "include/math.h"
 #include "src/math/fdim.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FDimTest = FDimTestTemplate<double>;
 
 TEST_F(FDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
 
 TEST_F(FDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
 
 TEST_F(FDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
 
 TEST_F(FDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
 
 TEST_F(FDimTest, InDoubleRange_fdim) { testInRange(&__llvm_libc::fdim); }

libc/test/src/math/fdimf_test.cpp

 //===-- Unittests for fdimf -----------------------------------------------===//
 //
 // 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 "FDimTest.h"
 
-#include "include/math.h"
 #include "src/math/fdimf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FDimTest = FDimTestTemplate<float>;
 
 TEST_F(FDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
 
 TEST_F(FDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
 
 TEST_F(FDimTest, NegInfArg_fdimf) { testNegInfArg(&__llvm_libc::fdimf); }
 
 TEST_F(FDimTest, BothZero_fdimf) { testBothZero(&__llvm_libc::fdimf); }
 
 TEST_F(FDimTest, InFloatRange_fdimf) { testInRange(&__llvm_libc::fdimf); }

libc/test/src/math/fdiml_test.cpp

 //===-- Unittests for fdiml -----------------------------------------------===//
 //
 // 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 "FDimTest.h"
 
-#include "include/math.h"
 #include "src/math/fdiml.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FDimTest = FDimTestTemplate<long double>;
 
 TEST_F(FDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
 
 TEST_F(FDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
 
 TEST_F(FDimTest, NegInfArg_fdiml) { testNegInfArg(&__llvm_libc::fdiml); }
 
 TEST_F(FDimTest, BothZero_fdiml) { testBothZero(&__llvm_libc::fdiml); }
 
 TEST_F(FDimTest, InLongDoubleRange_fdiml) { testInRange(&__llvm_libc::fdiml); }

libc/test/src/math/floor_test.cpp

 //===-- Unittests for floor -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/floor.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FloorTest, SpecialNumbers) {

libc/test/src/math/floorf_test.cpp

 //===-- Unittests for floorf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/floorf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FloorfTest, SpecialNumbers) {

libc/test/src/math/floorl_test.cpp

 //===-- Unittests for floorl ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/floorl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FloorlTest, SpecialNumbers) {

libc/test/src/math/fmax_test.cpp

 //===-- Unittests for fmax -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fmax.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(FmaxTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fmax(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, nan));

libc/test/src/math/fmaxf_test.cpp

 //===-- Unittests for fmaxf -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fmaxf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(FmaxfTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, nan));

libc/test/src/math/fmaxl_test.cpp

 //===-- Unittests for fmaxl -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fmaxl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(FmaxlTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, nan));

libc/test/src/math/fmin_test.cpp

 //===-- Unittests for fmin -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fmin.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(FminTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fmin(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, nan));

libc/test/src/math/fminf_test.cpp

 //===-- Unittests for fminf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fminf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(FminfTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fminf(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, nan));

libc/test/src/math/fminl_test.cpp

 //===-- Unittests for fmin -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/fminl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(FminlTest, NaNArg) {
   EXPECT_FP_EQ(inf, __llvm_libc::fminl(nan, inf));
   EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, nan));

libc/test/src/math/frexp_test.cpp

 //===-- Unittests for frexp -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/frexp.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;

libc/test/src/math/frexpf_test.cpp

 //===-- Unittests for frexpf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/frexpf.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;

libc/test/src/math/frexpl_test.cpp

 //===-- Unittests for frexpl ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/frexpl.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 TEST(FrexplTest, SpecialNumbers) {
   int exponent;
 

libc/test/src/math/hypotf_test.cpp

 //===-- Unittests for hypotf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/hypotf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 

libc/test/src/math/ilogb_test.cpp

 //===-- Unittests for ilogb -----------------------------------------------===//
 //
 // 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 "ILogbTest.h"
 
-#include "include/math.h"
 #include "src/math/ilogb.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 TEST_F(ILogbTest, SpecialNumbers_ilogb) {
   testSpecialNumbers<double>(&__llvm_libc::ilogb);
 }
 
 TEST_F(ILogbTest, PowersOfTwo_ilogb) {
   testPowersOfTwo<double>(&__llvm_libc::ilogb);
 }

libc/test/src/math/ilogbf_test.cpp

 //===-- Unittests for ilogbf ----------------------------------------------===//
 //
 // 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 "ILogbTest.h"
 
-#include "include/math.h"
 #include "src/math/ilogbf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 TEST_F(ILogbTest, SpecialNumbers_ilogbf) {
   testSpecialNumbers<float>(&__llvm_libc::ilogbf);
 }
 
 TEST_F(ILogbTest, PowersOfTwo_ilogbf) {
   testPowersOfTwo<float>(&__llvm_libc::ilogbf);
 }

libc/test/src/math/ilogbl_test.cpp

 //===-- Unittests for ilogbl ----------------------------------------------===//
 //
 // 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 "ILogbTest.h"
 
-#include "include/math.h"
 #include "src/math/ilogbl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using RunContext = __llvm_libc::testing::RunContext;
 
 TEST_F(ILogbTest, SpecialNumbers_ilogbl) {
   testSpecialNumbers<long double>(&__llvm_libc::ilogbl);
 }
 
 TEST_F(ILogbTest, PowersOfTwo_ilogbl) {

libc/test/src/math/logb_test.cpp

 //===-- Unittests for logb ------------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/logb.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
 using Properties = __llvm_libc::fputil::FloatProperties<double>;
 
 TEST(LogbTest, SpecialNumbers) {

libc/test/src/math/logbf_test.cpp

 //===-- Unittests for logbf -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/logbf.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
 using Properties = __llvm_libc::fputil::FloatProperties<float>;
 
 TEST(LogbfTest, SpecialNumbers) {

libc/test/src/math/logbl_test.cpp

 //===-- Unittests for logbl -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/logbl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/ManipulationFunctions.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 TEST(logblTest, SpecialNumbers) {
   EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::inf()));
   EXPECT_TRUE(FPBits::inf() == __llvm_libc::logbl(FPBits::negInf()));
 
   EXPECT_TRUE(FPBits::negInf() == __llvm_libc::logbl(FPBits::zero()));

libc/test/src/math/modf_test.cpp

 //===-- Unittests for modf ------------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/modf.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/FPUtil/NearestIntegerOperations.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
 using Properties = __llvm_libc::fputil::FloatProperties<double>;
 
 TEST(ModfTest, SpecialNumbers) {

libc/test/src/math/modff_test.cpp

 //===-- Unittests for modff -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/modff.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/FPUtil/NearestIntegerOperations.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 
 using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
 using Properties = __llvm_libc::fputil::FloatProperties<float>;
 
 TEST(ModffTest, SpecialNumbers) {

libc/test/src/math/modfl_test.cpp

 //===-- Unittests for modfl -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/modfl.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/NearestIntegerOperations.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 TEST(modflTest, SpecialNumbers) {
   long double integral;
 
   EXPECT_TRUE(FPBits::zero() == __llvm_libc::modfl(FPBits::inf(), &integral));
   EXPECT_TRUE(FPBits::inf() == integral);

libc/test/src/math/remquo_test.cpp

 //===-- Unittests for remquo ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/remquo.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 

libc/test/src/math/remquof_test.cpp

 //===-- Unittests for remquof ---------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/remquof.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 

libc/test/src/math/remquol_test.cpp

 //===-- Unittests for remquol ---------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/remquol.h"
 #include "utils/FPUtil/BasicOperations.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 using UIntType = FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 

libc/test/src/math/round_test.cpp

 //===-- Unittests for round -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/round.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(RoundTest, SpecialNumbers) {

libc/test/src/math/roundf_test.cpp

 //===-- Unittests for roundf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/roundf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(RoundfTest, SpecialNumbers) {

libc/test/src/math/roundl_test.cpp

 //===-- Unittests for roundl ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/roundl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(RoundlTest, SpecialNumbers) {

libc/test/src/math/sincosf_test.cpp

 //===-- Unittests for sincosf ---------------------------------------------===//
 //
 // 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 "include/errno.h"
-#include "include/math.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/math/sincosf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/CPP/Array.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <stdint.h>
 
 using __llvm_libc::fputil::isNegativeQuietNaN;
 using __llvm_libc::fputil::isQuietNaN;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 

libc/test/src/math/sinf_test.cpp

 //===-- Unittests for sinf ------------------------------------------------===//
 //
 // 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 "include/errno.h"
-#include "include/math.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/math/sinf.h"
 #include "test/src/math/sdcomp26094.h"
 #include "utils/CPP/Array.h"
 #include "utils/FPUtil/BitPatterns.h"
 #include "utils/FPUtil/ClassificationFunctions.h"
 #include "utils/FPUtil/FloatOperations.h"
 #include "utils/FPUtil/FloatProperties.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 #include <stdint.h>
 
 using __llvm_libc::fputil::isNegativeQuietNaN;
 using __llvm_libc::fputil::isQuietNaN;
 using __llvm_libc::fputil::valueAsBits;
 using __llvm_libc::fputil::valueFromBits;
 

libc/test/src/math/sqrt_test.cpp

 //===-- Unittests for sqrt -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/sqrt.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 using UIntType = typename FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 constexpr UIntType HiddenBit =
     UIntType(1) << __llvm_libc::fputil::MantissaWidth<double>::value;

libc/test/src/math/sqrtf_test.cpp

 //===-- Unittests for sqrtf -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/sqrtf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 using UIntType = typename FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 constexpr UIntType HiddenBit =
     UIntType(1) << __llvm_libc::fputil::MantissaWidth<float>::value;

libc/test/src/math/sqrtl_test.cpp

 //===-- Unittests for sqrtl ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/sqrtl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 using UIntType = typename FPBits::UIntType;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 constexpr UIntType HiddenBit =
     UIntType(1) << __llvm_libc::fputil::MantissaWidth<long double>::value;

libc/test/src/math/trunc_test.cpp

 //===-- Unittests for trunc -----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/trunc.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(TruncTest, SpecialNumbers) {

libc/test/src/math/truncf_test.cpp

 //===-- Unittests for truncf ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/truncf.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(TruncfTest, SpecialNumbers) {

libc/test/src/math/truncl_test.cpp

 //===-- Unittests for truncl ----------------------------------------------===//
 //
 // 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 "include/math.h"
 #include "src/math/truncl.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
+#include <math.h>
 
 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(long double)
 
 TEST(TrunclTest, SpecialNumbers) {