This is an archive of the discontinued LLVM Phabricator instance.

Differential D107600

[libc][nfc] move ctype_utils and FPUtils to __support
ClosedPublic

Authored by michaelrj on Aug 5 2021, 2:31 PM.

Details

Reviewers
sivachandra
Commits
rGc120edc7b3e1: [libc][nfc] move ctype_utils and FPUtils to __support
Summary

Some ctype functions are called from other libc functions (e.g. isspace
is used in atoi). By moving ctype_utils.h to __support it becomes easier
to include just the implementations of these functions. For these
reasons the implementation for isspace was moved into
ctype_utils as well.

FPUtils was moved to simplify the build order, and to clarify which
files are a part of the actual libc.

Many files were modified to accomodate these changes, mostly changing
the #include paths.

Diff Detail

Event Timeline

michaelrj created this revision.Aug 5 2021, 2:31 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 5 2021, 2:31 PM
Herald added subscribers: libc-commits, ecnelises, tschuett. · View Herald Transcript
michaelrj requested review of this revision.Aug 5 2021, 2:31 PM
Harbormaster completed remote builds in B118264: Diff 364616.Aug 5 2021, 3:03 PM
sivachandra added a comment.Aug 5 2021, 3:04 PM

The appropriate CMake files have to be updated?

michaelrj updated this revision to Diff 364638.Aug 5 2021, 3:31 PM

also move FPUtils.

Herald added a subscriber: mgorny. · View Herald TranscriptAug 5 2021, 3:31 PM
michaelrj retitled this revision from [libc] move ctype_utils to __support to [libc][nfc] move ctype_utils and FPUtils to __support.Aug 5 2021, 3:31 PM
michaelrj edited the summary of this revision. (Show Details)

The cmake files have been updated, and the tests pass on my machine.

Harbormaster completed remote builds in B118280: Diff 364638.Aug 5 2021, 4:02 PM
sivachandra accepted this revision.Aug 6 2021, 10:13 AM

If all the tests are passing, go for it.

This revision is now accepted and ready to land.Aug 6 2021, 10:13 AM
This revision was landed with ongoing or failed builds.Aug 6 2021, 10:29 AM
Closed by commit rGc120edc7b3e1: [libc][nfc] move ctype_utils and FPUtils to __support (authored by michaelrj). · Explain Why
This revision was automatically updated to reflect the committed changes.
michaelrj added a commit: rGc120edc7b3e1: [libc][nfc] move ctype_utils and FPUtils to __support.

Revision Contents

PathSize
libc/
fuzzing/
math/
2 lines
2 lines
2 lines
2 lines
2 lines
src/
__support/
7 lines
__support/
ctype/
10 lines
ctype/
26 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
fenv/
22 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
math/
4 lines
2 lines
2 lines
generic/
150 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
src/
__support/
FPUtil/
utils/
FPUtil/
6 lines
2 lines
6 lines
6 lines
6 lines
6 lines
8 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
aarch64/
8 lines
6 lines
generic/
6 lines
x86_64/
8 lines
6 lines
test/
src/
fenv/
14 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
math/
158 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
4 lines
6 lines
4 lines
6 lines
4 lines
6 lines
6 lines
6 lines
6 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
differential_testing/
2 lines
2 lines
exhaustive/
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
generic/
6 lines
6 lines
6 lines
6 lines
4 lines
4 lines
4 lines
2 lines
utils/
FPUtil/
2 lines
2 lines
utils/
1 line
FPUtil/
aarch64/
generic/
x86_64/
MPFRWrapper/
2 lines
4 lines

Diff 364841

libc/fuzzing/math/CMakeLists.txt

Show All 39 Lines DEPENDS
libc.src.math.remquof libc.src.math.remquof
libc.src.math.remquol libc.src.math.remquol
libc.src.math.round libc.src.math.round
libc.src.math.roundf libc.src.math.roundf
libc.src.math.roundl libc.src.math.roundl
libc.src.math.trunc libc.src.math.trunc
libc.src.math.truncf libc.src.math.truncf
libc.src.math.truncl libc.src.math.truncl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
) )
add_libc_fuzzer( add_libc_fuzzer(
nextafter_differential_fuzz nextafter_differential_fuzz
SRCS SRCS
nextafter_differential_fuzz.cpp nextafter_differential_fuzz.cpp
HDRS HDRS
TwoInputSingleOutputDiff.h TwoInputSingleOutputDiff.h
DEPENDS DEPENDS
libc.src.math.nextafter libc.src.math.nextafter
libc.src.math.nextafterf libc.src.math.nextafterf
libc.src.math.nextafterl libc.src.math.nextafterl
) )

libc/fuzzing/math/Compare.h

//===-- Template functions to compare scalar values -------------*- C++ -*-===// //===-- Template functions to compare scalar values -------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_FUZZING_MATH_COMPARE_H #ifndef LLVM_LIBC_FUZZING_MATH_COMPARE_H
#define LLVM_LIBC_FUZZING_MATH_COMPARE_H #define LLVM_LIBC_FUZZING_MATH_COMPARE_H
#include "src/__support/FPUtil/FPBits.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#include "utils/FPUtil/FPBits.h"
template <typename T> template <typename T>
__llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value, __llvm_libc::cpp::EnableIfType<__llvm_libc::cpp::IsFloatingPointType<T>::Value,
bool> bool>
ValuesEqual(T x1, T x2) { ValuesEqual(T x1, T x2) {
__llvm_libc::fputil::FPBits<T> bits1(x1); __llvm_libc::fputil::FPBits<T> bits1(x1);
__llvm_libc::fputil::FPBits<T> bits2(x2); __llvm_libc::fputil::FPBits<T> bits2(x2);
// If either is NaN, we want both to be NaN. // If either is NaN, we want both to be NaN.
Show All 14 Lines

libc/fuzzing/math/RemQuoDiff.h

//===-- Template for diffing remquo results ---------------------*- C++ -*-===// //===-- Template for diffing remquo results ---------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include <math.h> #include <math.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
template <typename T> using RemQuoFunc = T (*)(T, T, int *); template <typename T> using RemQuoFunc = T (*)(T, T, int *);
template <typename T> template <typename T>
Show All 31 Lines

libc/fuzzing/math/SingleInputSingleOutputDiff.h

//===-- Template to diff single-input-single-output functions ---*- C++ -*-===// //===-- Template to diff single-input-single-output functions ---*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_FUZZING_MATH_SINGLE_INPUT_SINGLE_OUTPUT_DIFF_H #ifndef LLVM_LIBC_FUZZING_MATH_SINGLE_INPUT_SINGLE_OUTPUT_DIFF_H
#define LLVM_LIBC_FUZZING_MATH_SINGLE_INPUT_SINGLE_OUTPUT_DIFF_H #define LLVM_LIBC_FUZZING_MATH_SINGLE_INPUT_SINGLE_OUTPUT_DIFF_H
#include "fuzzing/math/Compare.h" #include "fuzzing/math/Compare.h"
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include <math.h> #include <math.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
template <typename T> using SingleInputSingleOutputFunc = T (*)(T); template <typename T> using SingleInputSingleOutputFunc = T (*)(T);
template <typename T> template <typename T>
Show All 40 Lines

libc/fuzzing/math/TwoInputSingleOutputDiff.h

//===-- Template to diff two-input-single-output functions ------*- C++ -*-===// //===-- Template to diff two-input-single-output functions ------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_FUZZING_MATH_TWO_INPUT_SINGLE_OUTPUT_DIFF_H #ifndef LLVM_LIBC_FUZZING_MATH_TWO_INPUT_SINGLE_OUTPUT_DIFF_H
#define LLVM_LIBC_FUZZING_MATH_TWO_INPUT_SINGLE_OUTPUT_DIFF_H #define LLVM_LIBC_FUZZING_MATH_TWO_INPUT_SINGLE_OUTPUT_DIFF_H
#include "fuzzing/math/Compare.h" #include "fuzzing/math/Compare.h"
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include <math.h> #include <math.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
template <typename T1, typename T2> template <typename T1, typename T2>
using TwoInputSingleOutputFunc = T1 (*)(T1, T2); using TwoInputSingleOutputFunc = T1 (*)(T1, T2);
Show All 19 Lines

libc/src/__support/CMakeLists.txt

add_header_library( add_header_library(
common common
HDRS HDRS
common.h common.h
endian.h endian.h
sanitizer.h sanitizer.h
) )
add_header_library( add_header_library(
ctype_utils
HDRS
ctype_utils.h
)
add_header_library(
integer_operations integer_operations
HDRS HDRS
integer_operations.h integer_operations.h
) )
add_subdirectory(FPUtil)

libc/src/__support/FPUtil/BasicOperations.h

  • This file was moved from libc/utils/FPUtil/BasicOperations.h.
//===-- Basic operations on floating point numbers --------------*- C++ -*-===// //===-- Basic operations on floating point numbers --------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
#define LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H
#include "FPBits.h" #include "FPBits.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstatic inline T fdim(T x, T y) {
} }
return (x > y ? x - y : 0); return (x > y ? x - y : 0);
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_BASIC_OPERATIONS_H

libc/src/__support/FPUtil/CMakeLists.txt

  • This file was moved from libc/utils/FPUtil/CMakeLists.txt.
Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines LibcFPTestHelpers
TestHelpers.h TestHelpers.h
) )
target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR}) target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
target_link_libraries(LibcFPTestHelpers LibcUnitTest) target_link_libraries(LibcFPTestHelpers LibcUnitTest)
add_dependencies( add_dependencies(
LibcFPTestHelpers LibcFPTestHelpers
LibcUnitTest LibcUnitTest
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )

libc/src/__support/FPUtil/DivisionAndRemainderOperations.h

  • This file was moved from libc/utils/FPUtil/DivisionAndRemainderOperations.h.
//===-- Floating point divsion and remainder operations ---------*- C++ -*-===// //===-- Floating point divsion and remainder operations ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
#define LLVM_LIBC_UTILS_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H
#include "FPBits.h" #include "FPBits.h"
#include "ManipulationFunctions.h" #include "ManipulationFunctions.h"
#include "NormalFloat.h" #include "NormalFloat.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Linesstatic inline T remquo(T x, T y, int &q) {
if (nativeRemainder == T(0.0)) if (nativeRemainder == T(0.0))
return __llvm_libc::fputil::copysign(T(0.0), x); return __llvm_libc::fputil::copysign(T(0.0), x);
return nativeRemainder; return nativeRemainder;
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DIVISION_AND_REMAINDER_OPERATIONS_H

libc/src/__support/FPUtil/DummyFEnvImpl.h

  • This file was moved from libc/utils/FPUtil/DummyFEnvImpl.h.
//===-- Dummy floating point environment manipulation functins --*- C++ -*-===// //===-- Dummy floating point environment manipulation functins --*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_DUMMY_FENVIMPL_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_H
#define LLVM_LIBC_UTILS_FPUTIL_DUMMY_FENVIMPL_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_H
#include <fenv.h> #include <fenv.h>
#include <math.h> #include <math.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
// All dummy functions silently succeed. // All dummy functions silently succeed.
Show All 12 Lines
static inline int getEnv(fenv_t *) { return 0; } static inline int getEnv(fenv_t *) { return 0; }
static inline int setEnv(const fenv_t *) { return 0; } static inline int setEnv(const fenv_t *) { return 0; }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_DUMMY_FENVIMPL_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_DUMMY_FENVIMPL_H

libc/src/__support/FPUtil/FEnvUtils.h

  • This file was moved from libc/utils/FPUtil/FEnvUtils.h.
//===-- Utilities for manipulating floating point environment ---*- C++ -*-===// //===-- Utilities for manipulating floating point environment ---*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_FENVUTILS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVUTILS_H
#define LLVM_LIBC_UTILS_FPUTIL_FENVUTILS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVUTILS_H
#ifdef __x86_64__ #ifdef __x86_64__
#include "x86_64/FEnvImpl.h" #include "x86_64/FEnvImpl.h"
#elif defined(__aarch64__) #elif defined(__aarch64__)
#include "aarch64/FEnvImpl.h" #include "aarch64/FEnvImpl.h"
#else #else
#include "DummyFEnvImpl.h" #include "DummyFEnvImpl.h"
#endif #endif
#endif // LLVM_LIBC_UTILS_FPUTIL_FENVUTILS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FENVUTILS_H

libc/src/__support/FPUtil/FMA.h

  • This file was moved from libc/utils/FPUtil/FMA.h.
//===-- Common header for FMA implementations -------------------*- C++ -*-===// //===-- Common header for FMA implementations -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_FMA_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H
#define LLVM_LIBC_UTILS_FPUTIL_FMA_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#ifdef __x86_64__ #ifdef __x86_64__
#include "x86_64/FMA.h" #include "x86_64/FMA.h"
#elif defined(__aarch64__) #elif defined(__aarch64__)
#include "aarch64/FMA.h" #include "aarch64/FMA.h"
#else #else
Show All 10 Linesstatic inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
return generic::fma(x, y, z); return generic::fma(x, y, z);
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif #endif
#endif // LLVM_LIBC_UTILS_FPUTIL_FMA_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H

libc/src/__support/FPUtil/FPBits.h

  • This file was moved from libc/utils/FPUtil/FPBits.h.
//===-- Abstract class for bit manipulation of float numbers. ---*- C++ -*-===// //===-- Abstract class for bit manipulation of float numbers. ---*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
#define LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
#include "PlatformDefs.h" #include "PlatformDefs.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#include "FloatProperties.h" #include "FloatProperties.h"
#include <stdint.h> #include <stdint.h>
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines static T buildNaN(UIntType v) {
return T(bits); return T(bits);
} }
}; };
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#ifdef SPECIAL_X86_LONG_DOUBLE #ifdef SPECIAL_X86_LONG_DOUBLE
#include "utils/FPUtil/LongDoubleBitsX86.h" #include "src/__support/FPUtil/LongDoubleBitsX86.h"
#endif #endif
#endif // LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/__support/FPUtil/FPExceptMatcher.h

  • This file was moved from libc/utils/FPUtil/FPExceptMatcher.h.
//===-- FPExceptMatcher.h ---------------------------------------*- C++ -*-===// //===-- FPExceptMatcher.h ---------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_FP_EXCEPT_MATCHER_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_EXCEPT_MATCHER_H
#define LLVM_LIBC_UTILS_FPUTIL_FP_EXCEPT_MATCHER_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_EXCEPT_MATCHER_H
#ifndef LLVM_LIBC_TEST_USE_FUCHSIA #ifndef LLVM_LIBC_TEST_USE_FUCHSIA
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
namespace testing { namespace testing {
Show All 40 Lines ASSERT_THAT( \
true, \ true, \
__llvm_libc::fputil::testing::FPExceptMatcher( \ __llvm_libc::fputil::testing::FPExceptMatcher( \
__llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller( \ __llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller( \
func))) func)))
#else #else
#define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE)) #define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE))
#endif // LLVM_LIBC_TEST_USE_FUCHSIA #endif // LLVM_LIBC_TEST_USE_FUCHSIA
#endif // LLVM_LIBC_UTILS_FPUTIL_FP_EXCEPT_MATCHER_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_EXCEPT_MATCHER_H

libc/src/__support/FPUtil/FPExceptMatcher.cpp

  • This file was moved from libc/utils/FPUtil/FPExceptMatcher.cpp.
The contents of this file were not changed.

libc/src/__support/FPUtil/FloatProperties.h

  • This file was moved from libc/utils/FPUtil/FloatProperties.h.
//===-- Properties of floating point numbers --------------------*- C++ -*-===// //===-- Properties of floating point numbers --------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_FLOAT_PROPERTIES_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_FLOAT_PROPERTIES_H
#define LLVM_LIBC_UTILS_FPUTIL_FLOAT_PROPERTIES_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FLOAT_PROPERTIES_H
#include "PlatformDefs.h" #include "PlatformDefs.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
template <typename T> struct FloatProperties {}; template <typename T> struct FloatProperties {};
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
}; };
template <typename BitsType> template <typename BitsType>
using FloatTypeT = typename FloatType<BitsType>::Type; using FloatTypeT = typename FloatType<BitsType>::Type;
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_PROPERTIES_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FLOAT_PROPERTIES_H

libc/src/__support/FPUtil/Hypot.h

  • This file was moved from libc/utils/FPUtil/Hypot.h.
//===-- Implementation of hypotf function ---------------------------------===// //===-- Implementation of hypotf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_HYPOT_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
#define LLVM_LIBC_UTILS_FPUTIL_HYPOT_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
#include "BasicOperations.h" #include "BasicOperations.h"
#include "FPBits.h" #include "FPBits.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Linesstatic inline T hypot(T x, T y) {
Y |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::value; Y |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::value;
return *reinterpret_cast<T *>(&Y); return *reinterpret_cast<T *>(&Y);
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_HYPOT_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H

libc/src/__support/FPUtil/LongDoubleBitsX86.h

  • This file was moved from libc/utils/FPUtil/LongDoubleBitsX86.h.
//===-- Bit representation of x86 long double numbers -----------*- C++ -*-===// //===-- Bit representation of x86 long double numbers -----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_LONG_DOUBLE_BITS_X86_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_LONG_DOUBLE_BITS_X86_H
#define LLVM_LIBC_UTILS_FPUTIL_LONG_DOUBLE_BITS_X86_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_LONG_DOUBLE_BITS_X86_H
#include "FPBits.h" #include "FPBits.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
static_assert( static_assert(
sizeof(FPBits<long double>) == sizeof(long double), sizeof(FPBits<long double>) == sizeof(long double),
"Internal long double representation does not match the machine format."); "Internal long double representation does not match the machine format.");
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_LONG_DOUBLE_BITS_X86_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_LONG_DOUBLE_BITS_X86_H

libc/src/__support/FPUtil/ManipulationFunctions.h

  • This file was moved from libc/utils/FPUtil/ManipulationFunctions.h.
//===-- Floating-point manipulation functions -------------------*- C++ -*-===// //===-- Floating-point manipulation functions -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H
#define LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H
#include "FPBits.h" #include "FPBits.h"
#include "NearestIntegerOperations.h" #include "NearestIntegerOperations.h"
#include "NormalFloat.h" #include "NormalFloat.h"
#include "PlatformDefs.h" #include "PlatformDefs.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#ifdef SPECIAL_X86_LONG_DOUBLE #ifdef SPECIAL_X86_LONG_DOUBLE
#include "NextAfterLongDoubleX86.h" #include "NextAfterLongDoubleX86.h"
#endif // SPECIAL_X86_LONG_DOUBLE #endif // SPECIAL_X86_LONG_DOUBLE
#endif // LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/src/__support/FPUtil/NearestIntegerOperations.h

  • This file was moved from libc/utils/FPUtil/NearestIntegerOperations.h.
//===-- Nearest integer floating-point operations ---------------*- C++ -*-===// //===-- Nearest integer floating-point operations ---------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
#define LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
#include "FEnvUtils.h" #include "FEnvUtils.h"
#include "FPBits.h" #include "FPBits.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#include <math.h> #include <math.h>
#if math_errhandling & MATH_ERRNO #if math_errhandling & MATH_ERRNO
▲ Show 20 Lines • Show All 276 Lines • ▼ Show 20 Lines
static inline I roundToSignedIntegerUsingCurrentRoundingMode(F x) { static inline I roundToSignedIntegerUsingCurrentRoundingMode(F x) {
return internal::roundedFloatToSignedInteger<F, I>( return internal::roundedFloatToSignedInteger<F, I>(
roundUsingCurrentRoundingMode(x)); roundUsingCurrentRoundingMode(x));
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEAREST_INTEGER_OPERATIONS_H

libc/src/__support/FPUtil/NextAfterLongDoubleX86.h

  • This file was moved from libc/utils/FPUtil/NextAfterLongDoubleX86.h.
//===-- nextafter implementation for x86 long double numbers ----*- C++ -*-===// //===-- nextafter implementation for x86 long double numbers ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H
#define LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H
#include "FPBits.h" #include "FPBits.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesstatic inline long double nextafter(long double from, long double to) {
return *reinterpret_cast<long double *>(&intVal); return *reinterpret_cast<long double *>(&intVal);
// TODO: Raise floating point exceptions as required by the standard. // TODO: Raise floating point exceptions as required by the standard.
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NEXT_AFTER_LONG_DOUBLE_X86_H

libc/src/__support/FPUtil/NormalFloat.h

  • This file was moved from libc/utils/FPUtil/NormalFloat.h.
//===-- A class to store a normalized floating point number -----*- C++ -*-===// //===-- A class to store a normalized floating point number -----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_NORMAL_FLOAT_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
#define LLVM_LIBC_UTILS_FPUTIL_NORMAL_FLOAT_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H
#include "FPBits.h" #include "FPBits.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Linestemplate <> inline NormalFloat<long double>::operator long double() const {
result.setImplicitBit(1); result.setImplicitBit(1);
return static_cast<long double>(result); return static_cast<long double>(result);
} }
#endif // SPECIAL_X86_LONG_DOUBLE #endif // SPECIAL_X86_LONG_DOUBLE
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_NORMAL_FLOAT_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_NORMAL_FLOAT_H

libc/src/__support/FPUtil/PlatformDefs.h

  • This file was moved from libc/utils/FPUtil/PlatformDefs.h.
//===-- Platform specific macro definitions ---------------------*- C++ -*-===// //===-- Platform specific macro definitions ---------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_PLATFORM_DEFS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H
#define LLVM_LIBC_UTILS_FPUTIL_PLATFORM_DEFS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H
#if defined(__x86_64__) || defined(__i386__) #if defined(__x86_64__) || defined(__i386__)
#define X87_FPU #define X87_FPU
#endif #endif
#if defined(_WIN32) #if defined(_WIN32)
#define LONG_DOUBLE_IS_DOUBLE #define LONG_DOUBLE_IS_DOUBLE
#endif #endif
#if !defined(LONG_DOUBLE_IS_DOUBLE) && defined(X87_FPU) #if !defined(LONG_DOUBLE_IS_DOUBLE) && defined(X87_FPU)
#define SPECIAL_X86_LONG_DOUBLE #define SPECIAL_X86_LONG_DOUBLE
#endif #endif
#endif // LLVM_LIBC_UTILS_FPUTIL_PLATFORM_DEFS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_PLATFORM_DEFS_H

libc/src/__support/FPUtil/PolyEval.h

  • This file was moved from libc/utils/FPUtil/PolyEval.h.
//===-- Common header for PolyEval implementations --------------*- C++ -*-===// //===-- Common header for PolyEval implementations --------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_POLYEVAL_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H
#define LLVM_LIBC_UTILS_FPUTIL_POLYEVAL_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
// Evaluate polynomial using Horner's Scheme: // 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 // 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) ... ) ) ). // evaluated it as: a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
// We will use fma instructions if available. // We will use fma instructions if available.
// Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call // Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
Show All 27 Linesstatic inline T polyeval(T x, T a0, Ts... a) {
return x * polyeval(x, a...) + a0; return x * polyeval(x, a...) + a0;
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif #endif
#endif // LLVM_LIBC_UTILS_FPUTIL_FMA_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FMA_H

libc/src/__support/FPUtil/Sqrt.h

  • This file was moved from libc/utils/FPUtil/Sqrt.h.
//===-- Square root of IEEE 754 floating point numbers ----------*- C++ -*-===// //===-- Square root of IEEE 754 floating point numbers ----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_SQRT_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_H
#define LLVM_LIBC_UTILS_FPUTIL_SQRT_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_H
#include "FPBits.h" #include "FPBits.h"
#include "PlatformDefs.h" #include "PlatformDefs.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#ifdef SPECIAL_X86_LONG_DOUBLE #ifdef SPECIAL_X86_LONG_DOUBLE
#include "SqrtLongDoubleX86.h" #include "SqrtLongDoubleX86.h"
#endif // SPECIAL_X86_LONG_DOUBLE #endif // SPECIAL_X86_LONG_DOUBLE
#endif // LLVM_LIBC_UTILS_FPUTIL_SQRT_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_H

libc/src/__support/FPUtil/SqrtLongDoubleX86.h

  • This file was moved from libc/utils/FPUtil/SqrtLongDoubleX86.h.
//===-- Square root of x86 long double numbers ------------------*- C++ -*-===// //===-- Square root of x86 long double numbers ------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_SQRT_LONG_DOUBLE_X86_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H
#define LLVM_LIBC_UTILS_FPUTIL_SQRT_LONG_DOUBLE_X86_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H
#include "FPBits.h" #include "FPBits.h"
#include "Sqrt.h" #include "Sqrt.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines if (bits.isInfOrNaN()) {
return out; return out;
} }
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_SQRT_LONG_DOUBLE_X86_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_SQRT_LONG_DOUBLE_X86_H

libc/src/__support/FPUtil/TestHelpers.h

  • This file was moved from libc/utils/FPUtil/TestHelpers.h.
//===-- TestMatchers.h ------------------------------------------*- C++ -*-===// //===-- TestMatchers.h ------------------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_TEST_HELPERS_H
#define LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_TEST_HELPERS_H
#include "FPBits.h" #include "FPBits.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
namespace testing { namespace testing {
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines EXPECT_THAT( \
expected)) expected))
#define ASSERT_FP_NE(expected, actual) \ #define ASSERT_FP_NE(expected, actual) \
ASSERT_THAT( \ ASSERT_THAT( \
actual, \ actual, \
__llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \ __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
expected)) expected))
#endif // LLVM_LIBC_UTILS_FPUTIL_TEST_HELPERS_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_TEST_HELPERS_H

libc/src/__support/FPUtil/TestHelpers.cpp

  • This file was moved from libc/utils/FPUtil/TestHelpers.cpp.
The contents of this file were not changed.

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

  • This file was moved from libc/utils/FPUtil/aarch64/FEnvImpl.h.
//===-- aarch64 floating point env manipulation functions -------*- C++ -*-===// //===-- aarch64 floating point env manipulation functions -------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_AARCH64_FENVIMPL_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H
#define LLVM_LIBC_UTILS_FPUTIL_AARCH64_FENVIMPL_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H
#include <arm_acle.h> #include <arm_acle.h>
#include <fenv.h> #include <fenv.h>
#include <stdint.h> #include <stdint.h>
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
struct FEnv { struct FEnv {
struct FPState { struct FPState {
uint32_t ControlWord; uint32_t ControlWord;
uint32_t StatusWord; uint32_t StatusWord;
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 Linesstatic inline int setEnv(const fenv_t *envp) {
FEnv::writeControlWord(state->ControlWord); FEnv::writeControlWord(state->ControlWord);
FEnv::writeStatusWord(state->StatusWord); FEnv::writeStatusWord(state->StatusWord);
return 0; return 0;
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_AARCH64_FENVIMPL_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H

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

  • This file was moved from libc/utils/FPUtil/aarch64/FMA.h.
//===-- Aarch64 implementations of the fma function -------------*- C++ -*-===// //===-- Aarch64 implementations of the fma function -------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_AARCH64_FMA_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H
#define LLVM_LIBC_UTILS_FPUTIL_AARCH64_FMA_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
template <typename T> template <typename T>
cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, T z) { cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, T z) {
Show All 11 Lines __asm__ __volatile__("fmadd %d0, %d1, %d2, %d3\n\t"
: "=w"(result) : "=w"(result)
: "w"(x), "w"(y), "w"(z)); : "w"(x), "w"(y), "w"(z));
return result; return result;
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_AARCH64_FMA_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FMA_H

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

  • This file was moved from libc/utils/FPUtil/generic/FMA.h.
//===-- Common header for FMA implementations -------------------*- C++ -*-===// //===-- Common header for FMA implementations -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_GENERIC_FMA_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
#define LLVM_LIBC_UTILS_FPUTIL_GENERIC_FMA_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
namespace generic { namespace generic {
template <typename T> template <typename T>
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstatic inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
return static_cast<float>(static_cast<double>(bit_sum)); return static_cast<float>(static_cast<double>(bit_sum));
} }
} // namespace generic } // namespace generic
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_GENERIC_FMA_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H

libc/src/__support/FPUtil/generic/README.md

  • This file was moved from libc/utils/FPUtil/generic/README.md.
The contents of this file were not changed.

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

  • This file was moved from libc/utils/FPUtil/x86_64/FEnvImpl.h.
//===-- x86_64 floating point env manipulation functions --------*- C++ -*-===// //===-- x86_64 floating point env manipulation functions --------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_X86_64_FENVIMPL_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H
#define LLVM_LIBC_UTILS_FPUTIL_X86_64_FENVIMPL_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H
#include <fenv.h> #include <fenv.h>
#include <stdint.h> #include <stdint.h>
#include "src/__support/sanitizer.h" #include "src/__support/sanitizer.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
▲ Show 20 Lines • Show All 214 Lines • ▼ Show 20 Linesstatic inline int raiseExcept(int excepts) {
// Manual, Vol 1". // Manual, Vol 1".
// FPU status word is read for each exception seperately as the // FPU status word is read for each exception seperately as the
// exception handler can potentially write to it (typically to clear // exception handler can potentially write to it (typically to clear
// the corresponding exception flag). By reading it separately, we // the corresponding exception flag). By reading it separately, we
// ensure that the writes by the exception handler are maintained // ensure that the writes by the exception handler are maintained
// when raising the next exception. // when raising the next exception.
auto raiseHelper = [](uint16_t singleExceptFlag) { auto raiseHelper = [](uint16_t singleExceptFlag) {
internal::X87StateDescriptor state; internal::X87StateDescriptor state;
internal::getX87StateDescriptor(state); internal::getX87StateDescriptor(state);
state.StatusWord |= singleExceptFlag; state.StatusWord |= singleExceptFlag;
internal::writeX87StateDescriptor(state); internal::writeX87StateDescriptor(state);
internal::fwait(); internal::fwait();
}; };
if (statusValue & internal::ExceptionFlags::Invalid) if (statusValue & internal::ExceptionFlags::Invalid)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Linesstatic inline int setEnv(const fenv_t *envp) {
internal::writeMXCSR(state->MXCSR); internal::writeMXCSR(state->MXCSR);
return 0; return 0;
} }
#endif #endif
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_X86_64_FENVIMPL_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H

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

  • This file was moved from libc/utils/FPUtil/x86_64/FMA.h.
//===-- x86_64 implementations of the fma function --------------*- C++ -*-===// //===-- x86_64 implementations of the fma function --------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_UTILS_FPUTIL_X86_64_FMA_H #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H
#define LLVM_LIBC_UTILS_FPUTIL_X86_64_FMA_H #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace fputil { namespace fputil {
template <typename T> template <typename T>
static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y, static inline cpp::EnableIfType<cpp::IsSame<T, float>::Value, T> fma(T x, T y,
Show All 13 Lines __asm__ __volatile__("vfmadd213sd %x2, %x1, %x0"
: "+x"(result) : "+x"(result)
: "x"(y), "x"(z)); : "x"(y), "x"(z));
return result; return result;
} }
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_X86_64_FMA_H #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FMA_H

libc/src/__support/ctype_utils.h

  • This file was moved from libc/src/ctype/ctype_utils.h.
//===-- Collection of utils for implementing ctype functions-------*-C++-*-===// //===-- Collection of utils for implementing ctype functions-------*-C++-*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_CTYPE_CTYPE_UTILS_H #ifndef LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H
#define LLVM_LIBC_SRC_CTYPE_CTYPE_UTILS_H #define LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H
namespace __llvm_libc { namespace __llvm_libc {
namespace internal { namespace internal {
// ------------------------------------------------------ // ------------------------------------------------------
// Rationale: Since these classification functions are // Rationale: Since these classification functions are
// called in other functions, we will avoid the overhead // called in other functions, we will avoid the overhead
// of a function call by inlining them. // of a function call by inlining them.
// ------------------------------------------------------ // ------------------------------------------------------
static constexpr int isalpha(unsigned ch) { return (ch | 32) - 'a' < 26; } static constexpr int isalpha(unsigned ch) { return (ch | 32) - 'a' < 26; }
static constexpr int isdigit(unsigned ch) { return (ch - '0') < 10; } static constexpr int isdigit(unsigned ch) { return (ch - '0') < 10; }
static constexpr int isalnum(unsigned ch) { return isalpha(ch) || isdigit(ch); } static constexpr int isalnum(unsigned ch) { return isalpha(ch) || isdigit(ch); }
static constexpr int isgraph(unsigned ch) { return 0x20 < ch && ch < 0x7f; } static constexpr int isgraph(unsigned ch) { return 0x20 < ch && ch < 0x7f; }
static constexpr int islower(unsigned ch) { return (ch - 'a') < 26; } static constexpr int islower(unsigned ch) { return (ch - 'a') < 26; }
static constexpr int isupper(unsigned ch) { return (ch - 'A') < 26; } static constexpr int isupper(unsigned ch) { return (ch - 'A') < 26; }
static constexpr int isspace(unsigned ch) {
return ch == ' ' || (ch - '\t') < 5;
}
} // namespace internal } // namespace internal
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_CTYPE_UTILS_H #endif // LLVM_LIBC_SRC_SUPPORT_CTYPE_UTILS_H

libc/src/ctype/CMakeLists.txt

add_header_library(
ctype_utils
HDRS
ctype_utils.h
)
add_entrypoint_object( add_entrypoint_object(
isalnum isalnum
SRCS SRCS
isalnum.cpp isalnum.cpp
HDRS HDRS
isalnum.h isalnum.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isalpha isalpha
SRCS SRCS
isalpha.cpp isalpha.cpp
HDRS HDRS
isalpha.h isalpha.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isascii isascii
SRCS SRCS
isascii.cpp isascii.cpp
HDRS HDRS
isascii.h isascii.h
Show All 17 Lines
add_entrypoint_object( add_entrypoint_object(
isdigit isdigit
SRCS SRCS
isdigit.cpp isdigit.cpp
HDRS HDRS
isdigit.h isdigit.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isgraph isgraph
SRCS SRCS
isgraph.cpp isgraph.cpp
HDRS HDRS
isgraph.h isgraph.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
islower islower
SRCS SRCS
islower.cpp islower.cpp
HDRS HDRS
islower.h islower.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isprint isprint
SRCS SRCS
isprint.cpp isprint.cpp
HDRS HDRS
isprint.h isprint.h
) )
add_entrypoint_object( add_entrypoint_object(
ispunct ispunct
SRCS SRCS
ispunct.cpp ispunct.cpp
HDRS HDRS
ispunct.h ispunct.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isspace isspace
SRCS SRCS
isspace.cpp isspace.cpp
HDRS HDRS
isspace.h isspace.h
) )
add_entrypoint_object( add_entrypoint_object(
isupper isupper
SRCS SRCS
isupper.cpp isupper.cpp
HDRS HDRS
isupper.h isupper.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
isxdigit isxdigit
SRCS SRCS
isxdigit.cpp isxdigit.cpp
HDRS HDRS
isxdigit.h isxdigit.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
tolower tolower
SRCS SRCS
tolower.cpp tolower.cpp
HDRS HDRS
tolower.h tolower.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )
add_entrypoint_object( add_entrypoint_object(
toascii toascii
SRCS SRCS
toascii.cpp toascii.cpp
HDRS HDRS
toascii.h toascii.h
) )
add_entrypoint_object( add_entrypoint_object(
toupper toupper
SRCS SRCS
toupper.cpp toupper.cpp
HDRS HDRS
toupper.h toupper.h
DEPENDS DEPENDS
.ctype_utils libc.src.__support.ctype_utils
) )

libc/src/ctype/ctype_utils.h

  • This file was moved to libc/src/__support/ctype_utils.h.

libc/src/ctype/isalnum.cpp

//===-- Implementation of isalnum------------------------------------------===// //===-- Implementation of isalnum------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isalnum.h" #include "src/ctype/isalnum.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isalnum, (int c)) { return internal::isalnum(c); } LLVM_LIBC_FUNCTION(int, isalnum, (int c)) { return internal::isalnum(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isalpha.cpp

//===-- Implementation of isalpha------------------------------------------===// //===-- Implementation of isalpha------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isalpha.h" #include "src/ctype/isalpha.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isalpha, (int c)) { return internal::isalpha(c); } LLVM_LIBC_FUNCTION(int, isalpha, (int c)) { return internal::isalpha(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isdigit.cpp

//===-- Implementation of isdigit------------------------------------------===// //===-- Implementation of isdigit------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isdigit.h" #include "src/ctype/isdigit.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isdigit, (int c)) { return internal::isdigit(c); } LLVM_LIBC_FUNCTION(int, isdigit, (int c)) { return internal::isdigit(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isgraph.cpp

//===-- Implementation of isgraph------------------------------------------===// //===-- Implementation of isgraph------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isgraph.h" #include "src/ctype/isgraph.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isgraph, (int c)) { return internal::isgraph(c); } LLVM_LIBC_FUNCTION(int, isgraph, (int c)) { return internal::isgraph(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/islower.cpp

//===-- Implementation of islower------------------------------------------===// //===-- Implementation of islower------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/islower.h" #include "src/ctype/islower.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, islower, (int c)) { return internal::islower(c); } LLVM_LIBC_FUNCTION(int, islower, (int c)) { return internal::islower(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/ispunct.cpp

//===-- Implementation of ispunct------------------------------------------===// //===-- Implementation of ispunct------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/ispunct.h" #include "src/ctype/ispunct.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, ispunct, (int c)) { LLVM_LIBC_FUNCTION(int, ispunct, (int c)) {
return !internal::isalnum(c) && internal::isgraph(c); return !internal::isalnum(c) && internal::isgraph(c);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isspace.cpp

//===-- Implementation of isspace------------------------------------------===// //===-- Implementation of isspace------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isspace.h" #include "src/ctype/isspace.h"
#include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isspace, (int c)) { LLVM_LIBC_FUNCTION(int, isspace, (int c)) { return internal::isspace(c); }
const unsigned ch = c;
return ch == ' ' || (ch - '\t') < 5;
}
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isupper.cpp

//===-- Implementation of isupper------------------------------------------===// //===-- Implementation of isupper------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isupper.h" #include "src/ctype/isupper.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isupper, (int c)) { return internal::isupper(c); } LLVM_LIBC_FUNCTION(int, isupper, (int c)) { return internal::isupper(c); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/isxdigit.cpp

//===-- Implementation of isxdigit-----------------------------------------===// //===-- Implementation of isxdigit-----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/isxdigit.h" #include "src/ctype/isxdigit.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, isxdigit, (int c)) { LLVM_LIBC_FUNCTION(int, isxdigit, (int c)) {
const unsigned ch = c; const unsigned ch = c;
return internal::isdigit(ch) || (ch | 32) - 'a' < 6; return internal::isdigit(ch) || (ch | 32) - 'a' < 6;
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/tolower.cpp

//===-- Implementation of tolower------------------------------------------===// //===-- Implementation of tolower------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/tolower.h" #include "src/ctype/tolower.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, tolower, (int c)) { LLVM_LIBC_FUNCTION(int, tolower, (int c)) {
if (internal::isupper(c)) if (internal::isupper(c))
return c + 'a' - 'A'; return c + 'a' - 'A';
return c; return c;
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/ctype/toupper.cpp

//===-- Implementation of toupper------------------------------------------===// //===-- Implementation of toupper------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/ctype/toupper.h" #include "src/ctype/toupper.h"
#include "src/ctype/ctype_utils.h" #include "src/__support/ctype_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
// TODO: Currently restricted to default locale. // TODO: Currently restricted to default locale.
// These should be extended using locale information. // These should be extended using locale information.
LLVM_LIBC_FUNCTION(int, toupper, (int c)) { LLVM_LIBC_FUNCTION(int, toupper, (int c)) {
if (internal::islower(c)) if (internal::islower(c))
return c + 'A' - 'a'; return c + 'A' - 'a';
return c; return c;
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
fegetround fegetround
SRCS SRCS
fegetround.cpp fegetround.cpp
HDRS HDRS
fegetround.h fegetround.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fesetround fesetround
SRCS SRCS
fesetround.cpp fesetround.cpp
HDRS HDRS
fesetround.h fesetround.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
feclearexcept feclearexcept
SRCS SRCS
feclearexcept.cpp feclearexcept.cpp
HDRS HDRS
feclearexcept.h feclearexcept.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
feraiseexcept feraiseexcept
SRCS SRCS
feraiseexcept.cpp feraiseexcept.cpp
HDRS HDRS
feraiseexcept.h feraiseexcept.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fetestexcept fetestexcept
SRCS SRCS
fetestexcept.cpp fetestexcept.cpp
HDRS HDRS
fetestexcept.h fetestexcept.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fegetenv fegetenv
SRCS SRCS
fegetenv.cpp fegetenv.cpp
HDRS HDRS
fegetenv.h fegetenv.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fesetenv fesetenv
SRCS SRCS
fesetenv.cpp fesetenv.cpp
HDRS HDRS
fesetenv.h fesetenv.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fegetexceptflag fegetexceptflag
SRCS SRCS
fegetexceptflag.cpp fegetexceptflag.cpp
HDRS HDRS
fegetexceptflag.h fegetexceptflag.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fesetexceptflag fesetexceptflag
SRCS SRCS
fesetexceptflag.cpp fesetexceptflag.cpp
HDRS HDRS
fesetexceptflag.h fesetexceptflag.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
feholdexcept feholdexcept
SRCS SRCS
feholdexcept.cpp feholdexcept.cpp
HDRS HDRS
feholdexcept.h feholdexcept.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
feupdateenv feupdateenv
SRCS SRCS
feupdateenv.cpp feupdateenv.cpp
HDRS HDRS
feupdateenv.h feupdateenv.h
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )

libc/src/fenv/feclearexcept.cpp

//===-- Implementation of feclearexcept function --------------------------===// //===-- Implementation of feclearexcept function --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feclearexcept.h" #include "src/fenv/feclearexcept.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feclearexcept, (int e)) { LLVM_LIBC_FUNCTION(int, feclearexcept, (int e)) {
return fputil::clearExcept(e); return fputil::clearExcept(e);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fegetenv.cpp

//===-- Implementation of fegetenv function -----------------------------===// //===-- Implementation of fegetenv function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fegetenv.h" #include "src/fenv/fegetenv.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fegetenv, (fenv_t * envp)) { LLVM_LIBC_FUNCTION(int, fegetenv, (fenv_t * envp)) {
return fputil::getEnv(envp); return fputil::getEnv(envp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fegetexceptflag.cpp

//===-- Implementation of fegetexceptflag function ------------------------===// //===-- Implementation of fegetexceptflag function ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fegetexceptflag.h" #include "src/fenv/fegetexceptflag.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fegetexceptflag, (fexcept_t * flagp, int excepts)) { LLVM_LIBC_FUNCTION(int, fegetexceptflag, (fexcept_t * flagp, int excepts)) {
// TODO: Add a compile time check to see if the excepts actually fit in flagp. // TODO: Add a compile time check to see if the excepts actually fit in flagp.
*flagp = static_cast<fexcept_t>(fputil::testExcept(FE_ALL_EXCEPT) & excepts); *flagp = static_cast<fexcept_t>(fputil::testExcept(FE_ALL_EXCEPT) & excepts);
return 0; return 0;
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fegetround.cpp

//===-- Implementation of fegetround function -----------------------------===// //===-- Implementation of fegetround function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fegetround.h" #include "src/fenv/fegetround.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::getRound(); } LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::getRound(); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/feholdexcept.cpp

//===-- Implementation of feholdexcept function ---------------------------===// //===-- Implementation of feholdexcept function ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feholdexcept.h" #include "src/fenv/feholdexcept.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feholdexcept, (fenv_t * envp)) { LLVM_LIBC_FUNCTION(int, feholdexcept, (fenv_t * envp)) {
if (fputil::getEnv(envp) != 0) if (fputil::getEnv(envp) != 0)
return -1; return -1;
fputil::clearExcept(FE_ALL_EXCEPT); fputil::clearExcept(FE_ALL_EXCEPT);
fputil::disableExcept(FE_ALL_EXCEPT); fputil::disableExcept(FE_ALL_EXCEPT);
return 0; return 0;
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/feraiseexcept.cpp

//===-- Implementation of feraiseexcept function --------------------------===// //===-- Implementation of feraiseexcept function --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feraiseexcept.h" #include "src/fenv/feraiseexcept.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feraiseexcept, (int e)) { LLVM_LIBC_FUNCTION(int, feraiseexcept, (int e)) {
return fputil::raiseExcept(e); return fputil::raiseExcept(e);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fesetenv.cpp

//===-- Implementation of fesetenv function -----------------------------===// //===-- Implementation of fesetenv function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fesetenv.h" #include "src/fenv/fesetenv.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fesetenv, (const fenv_t *envp)) { LLVM_LIBC_FUNCTION(int, fesetenv, (const fenv_t *envp)) {
return fputil::setEnv(envp); return fputil::setEnv(envp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fesetexceptflag.cpp

//===-- Implementation of fesetexceptflag function ------------------------===// //===-- Implementation of fesetexceptflag function ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fesetexceptflag.h" #include "src/fenv/fesetexceptflag.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fesetexceptflag, LLVM_LIBC_FUNCTION(int, fesetexceptflag,
(const fexcept_t *flagp, int excepts)) { (const fexcept_t *flagp, int excepts)) {
// Since the return type of fetestexcept is int, we ensure that fexcept_t // Since the return type of fetestexcept is int, we ensure that fexcept_t
Show All 9 Lines

libc/src/fenv/fesetround.cpp

//===-- Implementation of fesetround function -----------------------------===// //===-- Implementation of fesetround function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fesetround.h" #include "src/fenv/fesetround.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fesetround, (int m)) { return fputil::setRound(m); } LLVM_LIBC_FUNCTION(int, fesetround, (int m)) { return fputil::setRound(m); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/fetestexcept.cpp

//===-- Implementation of fetestexcept function ---------------------------===// //===-- Implementation of fetestexcept function ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fetestexcept.h" #include "src/fenv/fetestexcept.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, fetestexcept, (int e)) { return fputil::testExcept(e); } LLVM_LIBC_FUNCTION(int, fetestexcept, (int e)) { return fputil::testExcept(e); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/fenv/feupdateenv.cpp

//===-- Implementation of feupdateenv function ----------------------------===// //===-- Implementation of feupdateenv function ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feupdateenv.h" #include "src/fenv/feupdateenv.h"
#include "src/__support/FPUtil/FEnvUtils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FEnvUtils.h"
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, feupdateenv, (const fenv_t *envp)) { LLVM_LIBC_FUNCTION(int, feupdateenv, (const fenv_t *envp)) {
int current_excepts = fputil::testExcept(FE_ALL_EXCEPT); int current_excepts = fputil::testExcept(FE_ALL_EXCEPT);
if (fputil::setEnv(envp) != 0) if (fputil::setEnv(envp) != 0)
return -1; return -1;
return fputil::raiseExcept(current_excepts); return fputil::raiseExcept(current_excepts);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/CMakeLists.txt

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
add_entrypoint_object( add_entrypoint_object(
fmaf fmaf
SRCS SRCS
fmaf.cpp fmaf.cpp
HDRS HDRS
fmaf.h fmaf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fma fma
SRCS SRCS
fma.cpp fma.cpp
HDRS HDRS
fma.h fma.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_math_entrypoint_object(ceil) add_math_entrypoint_object(ceil)
add_math_entrypoint_object(ceilf) add_math_entrypoint_object(ceilf)
add_math_entrypoint_object(ceill) add_math_entrypoint_object(ceill)
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

libc/src/math/fma.cpp

//===-- Implementation of fma function ------------------------------------===// //===-- Implementation of fma function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fma.h" #include "src/math/fma.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FMA.h" #include "src/__support/FPUtil/FMA.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fma, (double x, double y, double z)) { LLVM_LIBC_FUNCTION(double, fma, (double x, double y, double z)) {
return fputil::fma(x, y, z); return fputil::fma(x, y, z);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmaf.cpp

//===-- Implementation of fmaf function -----------------------------------===// //===-- Implementation of fmaf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaf.h" #include "src/math/fmaf.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FMA.h" #include "src/__support/FPUtil/FMA.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fmaf, (float x, float y, float z)) { LLVM_LIBC_FUNCTION(float, fmaf, (float x, float y, float z)) {
return fputil::fma(x, y, z); return fputil::fma(x, y, z);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/CMakeLists.txt

add_entrypoint_object( add_entrypoint_object(
ceil ceil
SRCS SRCS
ceil.cpp ceil.cpp
HDRS HDRS
../ceil.h ../ceil.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ceilf ceilf
SRCS SRCS
ceilf.cpp ceilf.cpp
HDRS HDRS
../ceilf.h ../ceilf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ceill ceill
SRCS SRCS
ceill.cpp ceill.cpp
HDRS HDRS
../ceill.h ../ceill.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_object_library( add_object_library(
math_utils math_utils
SRCS SRCS
math_utils.cpp math_utils.cpp
Show All 32 Linesadd_entrypoint_object(
SRCS SRCS
sinf.cpp sinf.cpp
HDRS HDRS
../sinf.h ../sinf.h
DEPENDS DEPENDS
.sincosf_utils .sincosf_utils
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O3 -O3
) )
add_entrypoint_object( add_entrypoint_object(
sincosf sincosf
SRCS SRCS
sincosf.cpp sincosf.cpp
HDRS HDRS
../sincosf.h ../sincosf.h
DEPENDS DEPENDS
.sincosf_utils .sincosf_utils
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
) )
add_entrypoint_object( add_entrypoint_object(
fabs fabs
SRCS SRCS
fabs.cpp fabs.cpp
HDRS HDRS
../fabs.h ../fabs.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fabsf fabsf
SRCS SRCS
fabsf.cpp fabsf.cpp
HDRS HDRS
../fabsf.h ../fabsf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fabsl fabsl
SRCS SRCS
fabsl.cpp fabsl.cpp
HDRS HDRS
../fabsl.h ../fabsl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
trunc trunc
SRCS SRCS
trunc.cpp trunc.cpp
HDRS HDRS
../trunc.h ../trunc.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
truncf truncf
SRCS SRCS
truncf.cpp truncf.cpp
HDRS HDRS
../truncf.h ../truncf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
truncl truncl
SRCS SRCS
truncl.cpp truncl.cpp
HDRS HDRS
../truncl.h ../truncl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
floor floor
SRCS SRCS
floor.cpp floor.cpp
HDRS HDRS
../floor.h ../floor.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
floorf floorf
SRCS SRCS
floorf.cpp floorf.cpp
HDRS HDRS
../floorf.h ../floorf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
floorl floorl
SRCS SRCS
floorl.cpp floorl.cpp
HDRS HDRS
../floorl.h ../floorl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
round round
SRCS SRCS
round.cpp round.cpp
HDRS HDRS
../round.h ../round.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
roundf roundf
SRCS SRCS
roundf.cpp roundf.cpp
HDRS HDRS
../roundf.h ../roundf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
roundl roundl
SRCS SRCS
roundl.cpp roundl.cpp
HDRS HDRS
../roundl.h ../roundl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lround lround
SRCS SRCS
lround.cpp lround.cpp
HDRS HDRS
../lround.h ../lround.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lroundf lroundf
SRCS SRCS
lroundf.cpp lroundf.cpp
HDRS HDRS
../lroundf.h ../lroundf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lroundl lroundl
SRCS SRCS
lroundl.cpp lroundl.cpp
HDRS HDRS
../lroundl.h ../lroundl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llround llround
SRCS SRCS
llround.cpp llround.cpp
HDRS HDRS
../llround.h ../llround.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llroundf llroundf
SRCS SRCS
llroundf.cpp llroundf.cpp
HDRS HDRS
../llroundf.h ../llroundf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llroundl llroundl
SRCS SRCS
llroundl.cpp llroundl.cpp
HDRS HDRS
../llroundl.h ../llroundl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
rint rint
SRCS SRCS
rint.cpp rint.cpp
HDRS HDRS
../rint.h ../rint.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
rintf rintf
SRCS SRCS
rintf.cpp rintf.cpp
HDRS HDRS
../rintf.h ../rintf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
rintl rintl
SRCS SRCS
rintl.cpp rintl.cpp
HDRS HDRS
../rintl.h ../rintl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lrint lrint
SRCS SRCS
lrint.cpp lrint.cpp
HDRS HDRS
../lrint.h ../lrint.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lrintf lrintf
SRCS SRCS
lrintf.cpp lrintf.cpp
HDRS HDRS
../lrintf.h ../lrintf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
lrintl lrintl
SRCS SRCS
lrintl.cpp lrintl.cpp
HDRS HDRS
../lrintl.h ../lrintl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llrint llrint
SRCS SRCS
llrint.cpp llrint.cpp
HDRS HDRS
../llrint.h ../llrint.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llrintf llrintf
SRCS SRCS
llrintf.cpp llrintf.cpp
HDRS HDRS
../llrintf.h ../llrintf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
llrintl llrintl
SRCS SRCS
llrintl.cpp llrintl.cpp
HDRS HDRS
../llrintl.h ../llrintl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nearbyint nearbyint
SRCS SRCS
nearbyint.cpp nearbyint.cpp
HDRS HDRS
../nearbyint.h ../nearbyint.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nearbyintf nearbyintf
SRCS SRCS
nearbyintf.cpp nearbyintf.cpp
HDRS HDRS
../nearbyintf.h ../nearbyintf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nearbyintl nearbyintl
SRCS SRCS
nearbyintl.cpp nearbyintl.cpp
HDRS HDRS
../nearbyintl.h ../nearbyintl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_object_library( add_object_library(
exp_utils exp_utils
HDRS HDRS
exp_utils.h exp_utils.h
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
add_entrypoint_object( add_entrypoint_object(
copysign copysign
SRCS SRCS
copysign.cpp copysign.cpp
HDRS HDRS
../copysign.h ../copysign.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
copysignf copysignf
SRCS SRCS
copysignf.cpp copysignf.cpp
HDRS HDRS
../copysignf.h ../copysignf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
copysignl copysignl
SRCS SRCS
copysignl.cpp copysignl.cpp
HDRS HDRS
../copysignl.h ../copysignl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
frexp frexp
SRCS SRCS
frexp.cpp frexp.cpp
HDRS HDRS
../frexp.h ../frexp.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
frexpf frexpf
SRCS SRCS
frexpf.cpp frexpf.cpp
HDRS HDRS
../frexpf.h ../frexpf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
frexpl frexpl
SRCS SRCS
frexpl.cpp frexpl.cpp
HDRS HDRS
../frexpl.h ../frexpl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ilogb ilogb
SRCS SRCS
ilogb.cpp ilogb.cpp
HDRS HDRS
../ilogb.h ../ilogb.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ilogbf ilogbf
SRCS SRCS
ilogbf.cpp ilogbf.cpp
HDRS HDRS
../ilogbf.h ../ilogbf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ilogbl ilogbl
SRCS SRCS
ilogbl.cpp ilogbl.cpp
HDRS HDRS
../ilogbl.h ../ilogbl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ldexp ldexp
SRCS SRCS
ldexp.cpp ldexp.cpp
HDRS HDRS
../ldexp.h ../ldexp.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ldexpf ldexpf
SRCS SRCS
ldexpf.cpp ldexpf.cpp
HDRS HDRS
../ldexpf.h ../ldexpf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
ldexpl ldexpl
SRCS SRCS
ldexpl.cpp ldexpl.cpp
HDRS HDRS
../ldexpl.h ../ldexpl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
logb logb
SRCS SRCS
logb.cpp logb.cpp
HDRS HDRS
../logb.h ../logb.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
logbf logbf
SRCS SRCS
logbf.cpp logbf.cpp
HDRS HDRS
../logbf.h ../logbf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
logbl logbl
SRCS SRCS
logbl.cpp logbl.cpp
HDRS HDRS
../logbl.h ../logbl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
modf modf
SRCS SRCS
modf.cpp modf.cpp
HDRS HDRS
../modf.h ../modf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
modff modff
SRCS SRCS
modff.cpp modff.cpp
HDRS HDRS
../modff.h ../modff.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
modfl modfl
SRCS SRCS
modfl.cpp modfl.cpp
HDRS HDRS
../modfl.h ../modfl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fmin fmin
SRCS SRCS
fmin.cpp fmin.cpp
HDRS HDRS
../fmin.h ../fmin.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fminf fminf
SRCS SRCS
fminf.cpp fminf.cpp
HDRS HDRS
../fminf.h ../fminf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fminl fminl
SRCS SRCS
fminl.cpp fminl.cpp
HDRS HDRS
../fminl.h ../fminl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fmax fmax
SRCS SRCS
fmax.cpp fmax.cpp
HDRS HDRS
../fmax.h ../fmax.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fmaxf fmaxf
SRCS SRCS
fmaxf.cpp fmaxf.cpp
HDRS HDRS
../fmaxf.h ../fmaxf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fmaxl fmaxl
SRCS SRCS
fmaxl.cpp fmaxl.cpp
HDRS HDRS
../fmaxl.h ../fmaxl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
sqrt sqrt
SRCS SRCS
sqrt.cpp sqrt.cpp
HDRS HDRS
../sqrt.h ../sqrt.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
sqrtf sqrtf
SRCS SRCS
sqrtf.cpp sqrtf.cpp
HDRS HDRS
../sqrtf.h ../sqrtf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
sqrtl sqrtl
SRCS SRCS
sqrtl.cpp sqrtl.cpp
HDRS HDRS
../sqrtl.h ../sqrtl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remquof remquof
SRCS SRCS
remquof.cpp remquof.cpp
HDRS HDRS
../remquof.h ../remquof.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remquo remquo
SRCS SRCS
remquo.cpp remquo.cpp
HDRS HDRS
../remquo.h ../remquo.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remquol remquol
SRCS SRCS
remquol.cpp remquol.cpp
HDRS HDRS
../remquol.h ../remquol.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remainderf remainderf
SRCS SRCS
remainderf.cpp remainderf.cpp
HDRS HDRS
../remainderf.h ../remainderf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remainder remainder
SRCS SRCS
remainder.cpp remainder.cpp
HDRS HDRS
../remainder.h ../remainder.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
remainderl remainderl
SRCS SRCS
remainderl.cpp remainderl.cpp
HDRS HDRS
../remainderl.h ../remainderl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
hypotf hypotf
SRCS SRCS
hypotf.cpp hypotf.cpp
HDRS HDRS
../hypotf.h ../hypotf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fdim fdim
SRCS SRCS
fdim.cpp fdim.cpp
HDRS HDRS
../fdim.h ../fdim.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fdimf fdimf
SRCS SRCS
fdimf.cpp fdimf.cpp
HDRS HDRS
../fdimf.h ../fdimf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
fdiml fdiml
SRCS SRCS
fdiml.cpp fdiml.cpp
HDRS HDRS
../fdiml.h ../fdiml.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
hypot hypot
SRCS SRCS
hypot.cpp hypot.cpp
HDRS HDRS
../hypot.h ../hypot.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nextafter nextafter
SRCS SRCS
nextafter.cpp nextafter.cpp
HDRS HDRS
../nextafter.h ../nextafter.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nextafterf nextafterf
SRCS SRCS
nextafterf.cpp nextafterf.cpp
HDRS HDRS
../nextafterf.h ../nextafterf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )
add_entrypoint_object( add_entrypoint_object(
nextafterl nextafterl
SRCS SRCS
nextafterl.cpp nextafterl.cpp
HDRS HDRS
../nextafterl.h ../nextafterl.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS COMPILE_OPTIONS
-O2 -O2
) )

libc/src/math/generic/ceil.cpp

//===-- Implementation of ceil function -----------------------------------===// //===-- Implementation of ceil function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceil.h" #include "src/math/ceil.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, ceil, (double x)) { return fputil::ceil(x); } LLVM_LIBC_FUNCTION(double, ceil, (double x)) { return fputil::ceil(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ceilf.cpp

//===-- Implementation of ceilf function ----------------------------------===// //===-- Implementation of ceilf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceilf.h" #include "src/math/ceilf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, ceilf, (float x)) { return fputil::ceil(x); } LLVM_LIBC_FUNCTION(float, ceilf, (float x)) { return fputil::ceil(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ceill.cpp

//===-- Implementation of ceill function ----------------------------------===// //===-- Implementation of ceill function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceill.h" #include "src/math/ceill.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, ceill, (long double x)) { LLVM_LIBC_FUNCTION(long double, ceill, (long double x)) {
return fputil::ceil(x); return fputil::ceil(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/copysign.cpp

//===-- Implementation of copysign function -------------------------------===// //===-- Implementation of copysign function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysign.h" #include "src/math/copysign.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, copysign, (double x, double y)) { LLVM_LIBC_FUNCTION(double, copysign, (double x, double y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/copysignf.cpp

//===-- Implementation of copysignf function ------------------------------===// //===-- Implementation of copysignf function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysignf.h" #include "src/math/copysignf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, copysignf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, copysignf, (float x, float y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/copysignl.cpp

//===-- Implementation of copysignl function ------------------------------===// //===-- Implementation of copysignl function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysignl.h" #include "src/math/copysignl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, copysignl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, copysignl, (long double x, long double y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/expm1f.cpp

//===-- Implementation of expm1f function ---------------------------------===// //===-- Implementation of expm1f function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/expm1f.h" #include "src/math/expm1f.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/PolyEval.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/math/expf.h" #include "src/math/expf.h"
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/PolyEval.h"
namespace __llvm_libc { namespace __llvm_libc {
// When |x| > Ln2, catastrophic cancellation does not occur with the // When |x| > Ln2, catastrophic cancellation does not occur with the
// subtraction expf(x) - 1.0f, so we use it to compute expm1f(x). // subtraction expf(x) - 1.0f, so we use it to compute expm1f(x).
// //
// We divide [-Ln2; Ln2] into 3 subintervals [-Ln2; -1/8], [-1/8; 1/8], // We divide [-Ln2; Ln2] into 3 subintervals [-Ln2; -1/8], [-1/8; 1/8],
// [1/8; Ln2]. And we use a degree-6 polynomial to approximate exp(x) - 1 in // [1/8; Ln2]. And we use a degree-6 polynomial to approximate exp(x) - 1 in
Show All 36 Lines

libc/src/math/generic/fabs.cpp

//===-- Implementation of fabs function -----------------------------------===// //===-- Implementation of fabs function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabs.h" #include "src/math/fabs.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fabs, (double x)) { return fputil::abs(x); } LLVM_LIBC_FUNCTION(double, fabs, (double x)) { return fputil::abs(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fabsf.cpp

//===-- Implementation of fabsf function ----------------------------------===// //===-- Implementation of fabsf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabsf.h" #include "src/math/fabsf.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fabsf, (float x)) { return fputil::abs(x); } LLVM_LIBC_FUNCTION(float, fabsf, (float x)) { return fputil::abs(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fabsl.cpp

//===-- Implementation of fabsf function ----------------------------------===// //===-- Implementation of fabsf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabsl.h" #include "src/math/fabsl.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fabsl, (long double x)) { LLVM_LIBC_FUNCTION(long double, fabsl, (long double x)) {
return fputil::abs(x); return fputil::abs(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fdim.cpp

//===-- Implementation of fdim function -----------------------------------===// //===-- Implementation of fdim function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdim.h" #include "src/math/fdim.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fdim, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fdim, (double x, double y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fdimf.cpp

//===-- Implementation of fdimf function ----------------------------------===// //===-- Implementation of fdimf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdimf.h" #include "src/math/fdimf.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fdimf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fdimf, (float x, float y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fdiml.cpp

//===-- Implementation of fdiml function ----------------------------------===// //===-- Implementation of fdiml function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdiml.h" #include "src/math/fdiml.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fdiml, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fdiml, (long double x, long double y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/floor.cpp

//===-- Implementation of floor function ----------------------------------===// //===-- Implementation of floor function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floor.h" #include "src/math/floor.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, floor, (double x)) { return fputil::floor(x); } LLVM_LIBC_FUNCTION(double, floor, (double x)) { return fputil::floor(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/floorf.cpp

//===-- Implementation of floorf function ---------------------------------===// //===-- Implementation of floorf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floorf.h" #include "src/math/floorf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, floorf, (float x)) { return fputil::floor(x); } LLVM_LIBC_FUNCTION(float, floorf, (float x)) { return fputil::floor(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/floorl.cpp

//===-- Implementation of floorl function ---------------------------------===// //===-- Implementation of floorl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floorl.h" #include "src/math/floorl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, floorl, (long double x)) { LLVM_LIBC_FUNCTION(long double, floorl, (long double x)) {
return fputil::floor(x); return fputil::floor(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fmax.cpp

//===-- Implementation of fmax function -----------------------------------===// //===-- Implementation of fmax function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmax.h" #include "src/math/fmax.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fmax, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fmax, (double x, double y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fmaxf.cpp

//===-- Implementation of fmaxf function ----------------------------------===// //===-- Implementation of fmaxf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaxf.h" #include "src/math/fmaxf.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fmaxf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fmaxf, (float x, float y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fmaxl.cpp

//===-- Implementation of fmaxl function ----------------------------------===// //===-- Implementation of fmaxl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaxl.h" #include "src/math/fmaxl.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fmaxl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fmaxl, (long double x, long double y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fmin.cpp

//===-- Implementation of fmin function -----------------------------------===// //===-- Implementation of fmin function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmin.h" #include "src/math/fmin.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fmin, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fmin, (double x, double y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fminf.cpp

//===-- Implementation of fminf function ----------------------------------===// //===-- Implementation of fminf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fminf.h" #include "src/math/fminf.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fminf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fminf, (float x, float y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/fminl.cpp

//===-- Implementation of fminl function ----------------------------------===// //===-- Implementation of fminl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fminl.h" #include "src/math/fminl.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/BasicOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fminl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fminl, (long double x, long double y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/frexp.cpp

//===-- Implementation of frexp function ----------------------------------===// //===-- Implementation of frexp function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexp.h" #include "src/math/frexp.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, frexp, (double x, int *exp)) { LLVM_LIBC_FUNCTION(double, frexp, (double x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/frexpf.cpp

//===-- Implementation of frexpf function ---------------------------------===// //===-- Implementation of frexpf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexpf.h" #include "src/math/frexpf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, frexpf, (float x, int *exp)) { LLVM_LIBC_FUNCTION(float, frexpf, (float x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/frexpl.cpp

//===-- Implementation of frexpl function ---------------------------------===// //===-- Implementation of frexpl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexpl.h" #include "src/math/frexpl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, frexpl, (long double x, int *exp)) { LLVM_LIBC_FUNCTION(long double, frexpl, (long double x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/hypot.cpp

//===-- Implementation of hypot function ----------------------------------===// //===-- Implementation of hypot function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/hypot.h" #include "src/math/hypot.h"
#include "src/__support/FPUtil/Hypot.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/Hypot.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, hypot, (double x, double y)) { LLVM_LIBC_FUNCTION(double, hypot, (double x, double y)) {
return __llvm_libc::fputil::hypot(x, y); return __llvm_libc::fputil::hypot(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/hypotf.cpp

//===-- Implementation of hypotf function ---------------------------------===// //===-- Implementation of hypotf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/hypotf.h" #include "src/math/hypotf.h"
#include "src/__support/FPUtil/Hypot.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/Hypot.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) {
return __llvm_libc::fputil::hypot(x, y); return __llvm_libc::fputil::hypot(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ilogb.cpp

//===-- Implementation of ilogb function ----------------------------------===// //===-- Implementation of ilogb function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogb.h" #include "src/math/ilogb.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogb, (double x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogb, (double x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ilogbf.cpp

//===-- Implementation of ilogbf function ---------------------------------===// //===-- Implementation of ilogbf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogbf.h" #include "src/math/ilogbf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogbf, (float x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogbf, (float x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ilogbl.cpp

//===-- Implementation of ilogbl function ---------------------------------===// //===-- Implementation of ilogbl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogbl.h" #include "src/math/ilogbl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogbl, (long double x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogbl, (long double x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ldexp.cpp

//===-- Implementation of ldexp function ----------------------------------===// //===-- Implementation of ldexp function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexp.h" #include "src/math/ldexp.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, ldexp, (double x, int exp)) { LLVM_LIBC_FUNCTION(double, ldexp, (double x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ldexpf.cpp

//===-- Implementation of ldexpf function ---------------------------------===// //===-- Implementation of ldexpf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexpf.h" #include "src/math/ldexpf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, ldexpf, (float x, int exp)) { LLVM_LIBC_FUNCTION(float, ldexpf, (float x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/ldexpl.cpp

//===-- Implementation of ldexpl function ---------------------------------===// //===-- Implementation of ldexpl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexpl.h" #include "src/math/ldexpl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, ldexpl, (long double x, int exp)) { LLVM_LIBC_FUNCTION(long double, ldexpl, (long double x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llrint.cpp

//===-- Implementation of llrint function ---------------------------------===// //===-- Implementation of llrint function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrint.h" #include "src/math/llrint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrint, (double x)) { LLVM_LIBC_FUNCTION(long long, llrint, (double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double,
long long>(x); long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llrintf.cpp

//===-- Implementation of llrintf function --------------------------------===// //===-- Implementation of llrintf function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrintf.h" #include "src/math/llrintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrintf, (float x)) { LLVM_LIBC_FUNCTION(long long, llrintf, (float x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>( return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>(
x); x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llrintl.cpp

//===-- Implementation of llrintl function --------------------------------===// //===-- Implementation of llrintl function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrintl.h" #include "src/math/llrintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrintl, (long double x)) { LLVM_LIBC_FUNCTION(long long, llrintl, (long double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
long long>(x); long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llround.cpp

//===-- Implementation of llround function --------------------------------===// //===-- Implementation of llround function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llround.h" #include "src/math/llround.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llround, (double x)) { LLVM_LIBC_FUNCTION(long long, llround, (double x)) {
return fputil::roundToSignedInteger<double, long long>(x); return fputil::roundToSignedInteger<double, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llroundf.cpp

//===-- Implementation of llroundf function -------------------------------===// //===-- Implementation of llroundf function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llroundf.h" #include "src/math/llroundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llroundf, (float x)) { LLVM_LIBC_FUNCTION(long long, llroundf, (float x)) {
return fputil::roundToSignedInteger<float, long long>(x); return fputil::roundToSignedInteger<float, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/llroundl.cpp

//===-- Implementation of llroundl function -------------------------------===// //===-- Implementation of llroundl function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llroundl.h" #include "src/math/llroundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llroundl, (long double x)) { LLVM_LIBC_FUNCTION(long long, llroundl, (long double x)) {
return fputil::roundToSignedInteger<long double, long long>(x); return fputil::roundToSignedInteger<long double, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/logb.cpp

//===-- Implementation of logb function -----------------------------------===// //===-- Implementation of logb function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logb.h" #include "src/math/logb.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, logb, (double x)) { return fputil::logb(x); } LLVM_LIBC_FUNCTION(double, logb, (double x)) { return fputil::logb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/logbf.cpp

//===-- Implementation of logbf function ---------------------------------===// //===-- Implementation of logbf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logbf.h" #include "src/math/logbf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, logbf, (float x)) { return fputil::logb(x); } LLVM_LIBC_FUNCTION(float, logbf, (float x)) { return fputil::logb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/logbl.cpp

//===-- Implementation of logbl function ---------------------------------===// //===-- Implementation of logbl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logbl.h" #include "src/math/logbl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, logbl, (long double x)) { LLVM_LIBC_FUNCTION(long double, logbl, (long double x)) {
return fputil::logb(x); return fputil::logb(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lrint.cpp

//===-- Implementation of lrint function ----------------------------------===// //===-- Implementation of lrint function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrint.h" #include "src/math/lrint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrint, (double x)) { LLVM_LIBC_FUNCTION(long, lrint, (double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x); return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lrintf.cpp

//===-- Implementation of lrintf function ---------------------------------===// //===-- Implementation of lrintf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrintf.h" #include "src/math/lrintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrintf, (float x)) { LLVM_LIBC_FUNCTION(long, lrintf, (float x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x); return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lrintl.cpp

//===-- Implementation of lrintl function ---------------------------------===// //===-- Implementation of lrintl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrintl.h" #include "src/math/lrintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrintl, (long double x)) { LLVM_LIBC_FUNCTION(long, lrintl, (long double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
long>(x); long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lround.cpp

//===-- Implementation of lround function ---------------------------------===// //===-- Implementation of lround function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lround.h" #include "src/math/lround.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lround, (double x)) { LLVM_LIBC_FUNCTION(long, lround, (double x)) {
return fputil::roundToSignedInteger<double, long>(x); return fputil::roundToSignedInteger<double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lroundf.cpp

//===-- Implementation of lroundf function --------------------------------===// //===-- Implementation of lroundf function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lroundf.h" #include "src/math/lroundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lroundf, (float x)) { LLVM_LIBC_FUNCTION(long, lroundf, (float x)) {
return fputil::roundToSignedInteger<float, long>(x); return fputil::roundToSignedInteger<float, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/lroundl.cpp

//===-- Implementation of lroundl function --------------------------------===// //===-- Implementation of lroundl function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lroundl.h" #include "src/math/lroundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lroundl, (long double x)) { LLVM_LIBC_FUNCTION(long, lroundl, (long double x)) {
return fputil::roundToSignedInteger<long double, long>(x); return fputil::roundToSignedInteger<long double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/modf.cpp

//===-- Implementation of modf function -----------------------------------===// //===-- Implementation of modf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modf.h" #include "src/math/modf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) { LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/modff.cpp

//===-- Implementation of modf function -----------------------------------===// //===-- Implementation of modf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modff.h" #include "src/math/modff.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) { LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/modfl.cpp

//===-- Implementation of modfl function ----------------------------------===// //===-- Implementation of modfl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modfl.h" #include "src/math/modfl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, modfl, (long double x, long double *iptr)) { LLVM_LIBC_FUNCTION(long double, modfl, (long double x, long double *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nearbyint.cpp

//===-- Implementation of nearbyint function ------------------------------===// //===-- Implementation of nearbyint function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyint.h" #include "src/math/nearbyint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) { LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nearbyintf.cpp

//===-- Implementation of nearbyintf function -----------------------------===// //===-- Implementation of nearbyintf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyintf.h" #include "src/math/nearbyintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) { LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nearbyintl.cpp

//===-- Implementation of nearbyintl function -----------------------------===// //===-- Implementation of nearbyintl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyintl.h" #include "src/math/nearbyintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) { LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nextafter.cpp

//===-- Implementation of nextafter function ------------------------------===// //===-- Implementation of nextafter function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafter.h" #include "src/math/nextafter.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) { LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nextafterf.cpp

//===-- Implementation of nextafterf function -----------------------------===// //===-- Implementation of nextafterf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafterf.h" #include "src/math/nextafterf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/nextafterl.cpp

//===-- Implementation of nextafterl function -----------------------------===// //===-- Implementation of nextafterl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafterl.h" #include "src/math/nextafterl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/ManipulationFunctions.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, nextafterl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, nextafterl, (long double x, long double y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remainder.cpp

//===-- Implementation of remainder function ------------------------------===// //===-- Implementation of remainder function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainder.h" #include "src/math/remainder.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) { LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remainderf.cpp

//===-- Implementation of remainderf function -----------------------------===// //===-- Implementation of remainderf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainderf.h" #include "src/math/remainderf.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remainderl.cpp

//===-- Implementation of remainderl function -----------------------------===// //===-- Implementation of remainderl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainderl.h" #include "src/math/remainderl.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, remainderl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, remainderl, (long double x, long double y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remquo.cpp

//===-- Implementation of remquo function ---------------------------------===// //===-- Implementation of remquo function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquo.h" #include "src/math/remquo.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *exp)) { LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remquof.cpp

//===-- Implementation of remquof function --------------------------------===// //===-- Implementation of remquof function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquof.h" #include "src/math/remquof.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *exp)) { LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/remquol.cpp

//===-- Implementation of remquol function --------------------------------===// //===-- Implementation of remquol function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquol.h" #include "src/math/remquol.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/DivisionAndRemainderOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, remquol, LLVM_LIBC_FUNCTION(long double, remquol,
(long double x, long double y, int *exp)) { (long double x, long double y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/rint.cpp

//===-- Implementation of rint function -----------------------------------===// //===-- Implementation of rint function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rint.h" #include "src/math/rint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, rint, (double x)) { LLVM_LIBC_FUNCTION(double, rint, (double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/rintf.cpp

//===-- Implementation of rintf function ----------------------------------===// //===-- Implementation of rintf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rintf.h" #include "src/math/rintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, rintf, (float x)) { LLVM_LIBC_FUNCTION(float, rintf, (float x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/rintl.cpp

//===-- Implementation of rintl function ----------------------------------===// //===-- Implementation of rintl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rintl.h" #include "src/math/rintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) { LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/round.cpp

//===-- Implementation of round function ----------------------------------===// //===-- Implementation of round function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/round.h" #include "src/math/round.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, round, (double x)) { return fputil::round(x); } LLVM_LIBC_FUNCTION(double, round, (double x)) { return fputil::round(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/roundf.cpp

//===-- Implementation of roundf function ---------------------------------===// //===-- Implementation of roundf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/roundf.h" #include "src/math/roundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, roundf, (float x)) { return fputil::round(x); } LLVM_LIBC_FUNCTION(float, roundf, (float x)) { return fputil::round(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/roundl.cpp

//===-- Implementation of roundl function ---------------------------------===// //===-- Implementation of roundl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/roundl.h" #include "src/math/roundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) {
return fputil::round(x); return fputil::round(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/sqrt.cpp

//===-- Implementation of sqrt function -----------------------------------===// //===-- Implementation of sqrt function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrt.h" #include "src/math/sqrt.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/Sqrt.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); } LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/sqrtf.cpp

//===-- Implementation of sqrtf function ----------------------------------===// //===-- Implementation of sqrtf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrtf.h" #include "src/math/sqrtf.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/Sqrt.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return fputil::sqrt(x); } LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return fputil::sqrt(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/sqrtl.cpp

//===-- Implementation of sqrtl function ----------------------------------===// //===-- Implementation of sqrtl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrtl.h" #include "src/math/sqrtl.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/Sqrt.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, sqrtl, (long double x)) { LLVM_LIBC_FUNCTION(long double, sqrtl, (long double x)) {
return fputil::sqrt(x); return fputil::sqrt(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/trunc.cpp

//===-- Implementation of trunc function ----------------------------------===// //===-- Implementation of trunc function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/trunc.h" #include "src/math/trunc.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return fputil::trunc(x); } LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return fputil::trunc(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/truncf.cpp

//===-- Implementation of truncf function ---------------------------------===// //===-- Implementation of truncf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/truncf.h" #include "src/math/truncf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, truncf, (float x)) { return fputil::trunc(x); } LLVM_LIBC_FUNCTION(float, truncf, (float x)) { return fputil::trunc(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/truncl.cpp

//===-- Implementation of truncl function ---------------------------------===// //===-- Implementation of truncl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/truncl.h" #include "src/math/truncl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/NearestIntegerOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, truncl, (long double x)) { LLVM_LIBC_FUNCTION(long double, truncl, (long double x)) {
return fputil::trunc(x); return fputil::trunc(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/test/src/fenv/CMakeLists.txt

Show All 15 Linesadd_libc_unittest(
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
exception_status_test.cpp exception_status_test.cpp
DEPENDS DEPENDS
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_libc_unittest( add_libc_unittest(
getenv_and_setenv_test getenv_and_setenv_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
getenv_and_setenv_test.cpp getenv_and_setenv_test.cpp
DEPENDS DEPENDS
libc.src.fenv.fegetenv libc.src.fenv.fegetenv
libc.src.fenv.fesetenv libc.src.fenv.fesetenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_libc_unittest( add_libc_unittest(
exception_flags_test exception_flags_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
exception_flags_test.cpp exception_flags_test.cpp
DEPENDS DEPENDS
libc.src.fenv.fegetexceptflag libc.src.fenv.fegetexceptflag
libc.src.fenv.fesetexceptflag libc.src.fenv.fesetexceptflag
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_libc_unittest( add_libc_unittest(
feupdateenv_test feupdateenv_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
feupdateenv_test.cpp feupdateenv_test.cpp
DEPENDS DEPENDS
libc.include.signal libc.include.signal
libc.src.fenv.feupdateenv libc.src.fenv.feupdateenv
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_libc_unittest( add_libc_unittest(
feclearexcept_test feclearexcept_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
feclearexcept_test.cpp feclearexcept_test.cpp
DEPENDS DEPENDS
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
if (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows"))) if (NOT (LLVM_USE_SANITIZER OR (${LIBC_TARGET_OS} STREQUAL "windows")))
# Sanitizers don't like SIGFPE. So, we will run the # Sanitizers don't like SIGFPE. So, we will run the
# tests which raise SIGFPE only in non-sanitizer builds. # tests which raise SIGFPE only in non-sanitizer builds.
# The tests are also disabled for Windows as they fail currently. # The tests are also disabled for Windows as they fail currently.
# TODO: Investigate and fix the windows failures and enable them for Windows. # TODO: Investigate and fix the windows failures and enable them for Windows.
add_fp_unittest( add_fp_unittest(
enabled_exceptions_test enabled_exceptions_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
enabled_exceptions_test.cpp enabled_exceptions_test.cpp
DEPENDS DEPENDS
libc.include.signal libc.include.signal
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
feholdexcept_test feholdexcept_test
SUITE SUITE
libc_fenv_unittests libc_fenv_unittests
SRCS SRCS
feholdexcept_test.cpp feholdexcept_test.cpp
DEPENDS DEPENDS
libc.include.fenv libc.include.fenv
libc.src.fenv.feholdexcept libc.src.fenv.feholdexcept
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
endif() endif()

libc/test/src/fenv/enabled_exceptions_test.cpp

//===-- Unittests for feraiseexcept with exceptions enabled ---------------===// //===-- Unittests for feraiseexcept with exceptions enabled ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feclearexcept.h" #include "src/fenv/feclearexcept.h"
#include "src/fenv/feraiseexcept.h" #include "src/fenv/feraiseexcept.h"
#include "src/fenv/fetestexcept.h" #include "src/fenv/fetestexcept.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/FPUtil/FPExceptMatcher.h" #include "src/__support/FPUtil/FPExceptMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
#include <signal.h> #include <signal.h>
// This test enables an exception and verifies that raising that exception // This test enables an exception and verifies that raising that exception
// triggers SIGFPE. // triggers SIGFPE.
TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) { TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libc/test/src/fenv/exception_flags_test.cpp

//===-- Unittests for fegetexceptflag and fesetexceptflag -----------------===// //===-- Unittests for fegetexceptflag and fesetexceptflag -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fegetexceptflag.h" #include "src/fenv/fegetexceptflag.h"
#include "src/fenv/fesetexceptflag.h" #include "src/fenv/fesetexceptflag.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
TEST(LlvmLibcFenvTest, GetExceptFlagAndSetExceptFlag) { TEST(LlvmLibcFenvTest, GetExceptFlagAndSetExceptFlag) {
// We will disable all exceptions to prevent invocation of the exception // We will disable all exceptions to prevent invocation of the exception
// handler. // handler.
__llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT); __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
Show All 38 Lines

libc/test/src/fenv/exception_status_test.cpp

//===-- Unittests for feclearexcept, feraiseexcept and fetestexpect -------===// //===-- Unittests for feclearexcept, feraiseexcept and fetestexpect -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feclearexcept.h" #include "src/fenv/feclearexcept.h"
#include "src/fenv/feraiseexcept.h" #include "src/fenv/feraiseexcept.h"
#include "src/fenv/fetestexcept.h" #include "src/fenv/fetestexcept.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) { TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
// This test raises a set of exceptions and checks that the exception // This test raises a set of exceptions and checks that the exception
// status flags are updated. The intention is really not to invoke the // status flags are updated. The intention is really not to invoke the
// exception handler. Hence, we will disable all exceptions at the // exception handler. Hence, we will disable all exceptions at the
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

libc/test/src/fenv/feclearexcept_test.cpp

//===-- Unittests for feclearexcept with exceptions enabled ---------------===// //===-- Unittests for feclearexcept with exceptions enabled ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feclearexcept.h" #include "src/fenv/feclearexcept.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
#include <stdint.h> #include <stdint.h>
TEST(LlvmLibcFEnvTest, ClearTest) { TEST(LlvmLibcFEnvTest, ClearTest) {
uint16_t excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW, uint16_t excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
FE_UNDERFLOW}; FE_UNDERFLOW};
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libc/test/src/fenv/feholdexcept_test.cpp

//===-- Unittests for feholdexcept with exceptions enabled ----------------===// //===-- Unittests for feholdexcept with exceptions enabled ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feholdexcept.h" #include "src/fenv/feholdexcept.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/FPUtil/FPExceptMatcher.h" #include "src/__support/FPUtil/FPExceptMatcher.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
TEST(LlvmLibcFEnvTest, RaiseAndCrash) { TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW, int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
FE_UNDERFLOW}; FE_UNDERFLOW};
Show All 27 Lines

libc/test/src/fenv/feupdateenv_test.cpp

//===-- Unittests for feupdateenv -----------------------------------------===// //===-- Unittests for feupdateenv -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/feupdateenv.h" #include "src/fenv/feupdateenv.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
#include <signal.h> #include <signal.h>
TEST(LlvmLibcFEnvTest, UpdateEnvTest) { TEST(LlvmLibcFEnvTest, UpdateEnvTest) {
__llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT); __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
__llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT); __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
fenv_t env; fenv_t env;
ASSERT_EQ(__llvm_libc::fputil::getEnv(&env), 0); ASSERT_EQ(__llvm_libc::fputil::getEnv(&env), 0);
__llvm_libc::fputil::setExcept(FE_INVALID | FE_INEXACT); __llvm_libc::fputil::setExcept(FE_INVALID | FE_INEXACT);
ASSERT_EQ(__llvm_libc::feupdateenv(&env), 0); ASSERT_EQ(__llvm_libc::feupdateenv(&env), 0);
ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_INVALID | FE_INEXACT), ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_INVALID | FE_INEXACT),
FE_INVALID | FE_INEXACT); FE_INVALID | FE_INEXACT);
} }

libc/test/src/fenv/getenv_and_setenv_test.cpp

//===-- Unittests for fegetenv and fesetenv -------------------------------===// //===-- Unittests for fegetenv and fesetenv -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/fenv/fegetenv.h" #include "src/fenv/fegetenv.h"
#include "src/fenv/fesetenv.h" #include "src/fenv/fesetenv.h"
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
TEST(LlvmLibcFenvTest, GetEnvAndSetEnv) { TEST(LlvmLibcFenvTest, GetEnvAndSetEnv) {
// We will disable all exceptions to prevent invocation of the exception // We will disable all exceptions to prevent invocation of the exception
// handler. // handler.
__llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT); __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
Show All 19 Lines

libc/test/src/math/CMakeLists.txt

add_libc_testsuite(libc_math_unittests) add_libc_testsuite(libc_math_unittests)
add_fp_unittest( add_fp_unittest(
cosf_test cosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
cosf_test.cpp cosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.cosf libc.src.math.cosf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
cos_test cos_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
cos_test.cpp cos_test.cpp
DEPENDS DEPENDS
libc.src.math.cos libc.src.math.cos
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sinf_test sinf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sinf_test.cpp sinf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.sinf libc.src.math.sinf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sin_test sin_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sin_test.cpp sin_test.cpp
DEPENDS DEPENDS
libc.src.math.sin libc.src.math.sin
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sincosf_test sincosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sincosf_test.cpp sincosf_test.cpp
HDRS HDRS
sdcomp26094.h sdcomp26094.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.src.math.sincosf libc.src.math.sincosf
libc.utils.CPP.standalone_cpp libc.utils.CPP.standalone_cpp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fabs_test fabs_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabs_test.cpp fabs_test.cpp
HDRS HDRS
FAbsTest.h FAbsTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabs libc.src.math.fabs
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fabsf_test fabsf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabsf_test.cpp fabsf_test.cpp
HDRS HDRS
FAbsTest.h FAbsTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabsf libc.src.math.fabsf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fabsl_test fabsl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fabsl_test.cpp fabsl_test.cpp
HDRS HDRS
FAbsTest.h FAbsTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fabsl libc.src.math.fabsl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
trunc_test trunc_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
trunc_test.cpp trunc_test.cpp
HDRS HDRS
TruncTest.h TruncTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.trunc libc.src.math.trunc
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
truncf_test truncf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
truncf_test.cpp truncf_test.cpp
HDRS HDRS
TruncTest.h TruncTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.truncf libc.src.math.truncf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
truncl_test truncl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
truncl_test.cpp truncl_test.cpp
HDRS HDRS
TruncTest.h TruncTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.truncl libc.src.math.truncl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ceil_test ceil_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceil_test.cpp ceil_test.cpp
HDRS HDRS
CeilTest.h CeilTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceil libc.src.math.ceil
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ceilf_test ceilf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceilf_test.cpp ceilf_test.cpp
HDRS HDRS
CeilTest.h CeilTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceilf libc.src.math.ceilf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ceill_test ceill_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ceill_test.cpp ceill_test.cpp
HDRS HDRS
CeilTest.h CeilTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ceill libc.src.math.ceill
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
floor_test floor_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floor_test.cpp floor_test.cpp
HDRS HDRS
FloorTest.h FloorTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floor libc.src.math.floor
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
floorf_test floorf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floorf_test.cpp floorf_test.cpp
HDRS HDRS
FloorTest.h FloorTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floorf libc.src.math.floorf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
floorl_test floorl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
floorl_test.cpp floorl_test.cpp
HDRS HDRS
FloorTest.h FloorTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floorl libc.src.math.floorl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
round_test round_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
round_test.cpp round_test.cpp
HDRS HDRS
RoundTest.h RoundTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.round libc.src.math.round
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
roundf_test roundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
roundf_test.cpp roundf_test.cpp
HDRS HDRS
RoundTest.h RoundTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.roundf libc.src.math.roundf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
roundl_test roundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
roundl_test.cpp roundl_test.cpp
HDRS HDRS
RoundTest.h RoundTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.roundl libc.src.math.roundl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lround_test lround_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lround_test.cpp lround_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lround libc.src.math.lround
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lroundf_test lroundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lroundf_test.cpp lroundf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lroundf libc.src.math.lroundf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lroundl_test lroundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lroundl_test.cpp lroundl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.lroundl libc.src.math.lroundl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llround_test llround_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llround_test.cpp llround_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llround libc.src.math.llround
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llroundf_test llroundf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llroundf_test.cpp llroundf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llroundf libc.src.math.llroundf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llroundl_test llroundl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llroundl_test.cpp llroundl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.errno.__errno_location libc.src.errno.__errno_location
libc.src.fenv.feclearexcept libc.src.fenv.feclearexcept
libc.src.fenv.feraiseexcept libc.src.fenv.feraiseexcept
libc.src.fenv.fetestexcept libc.src.fenv.fetestexcept
libc.src.math.llroundl libc.src.math.llroundl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
rint_test rint_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
rint_test.cpp rint_test.cpp
HDRS HDRS
RIntTest.h RIntTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.rint libc.src.math.rint
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
rintf_test rintf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
rintf_test.cpp rintf_test.cpp
HDRS HDRS
RIntTest.h RIntTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.rintf libc.src.math.rintf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
rintl_test rintl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
rintl_test.cpp rintl_test.cpp
HDRS HDRS
RIntTest.h RIntTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.rintl libc.src.math.rintl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lrint_test lrint_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lrint_test.cpp lrint_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.lrint libc.src.math.lrint
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lrintf_test lrintf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lrintf_test.cpp lrintf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.lrintf libc.src.math.lrintf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
lrintl_test lrintl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
lrintl_test.cpp lrintl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.lrintl libc.src.math.lrintl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llrint_test llrint_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llrint_test.cpp llrint_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.llrint libc.src.math.llrint
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llrintf_test llrintf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llrintf_test.cpp llrintf_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.llrintf libc.src.math.llrintf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
llrintl_test llrintl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
llrintl_test.cpp llrintl_test.cpp
HDRS HDRS
RoundToIntegerTest.h RoundToIntegerTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.llrintl libc.src.math.llrintl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
expf_test expf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expf_test.cpp expf_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.math.expf libc.src.math.expf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
exp2f_test exp2f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
exp2f_test.cpp exp2f_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.math.exp2f libc.src.math.exp2f
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
copysign_test copysign_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysign_test.cpp copysign_test.cpp
HDRS HDRS
CopySignTest.h CopySignTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysign libc.src.math.copysign
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
copysignf_test copysignf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysignf_test.cpp copysignf_test.cpp
HDRS HDRS
CopySignTest.h CopySignTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysignf libc.src.math.copysignf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
copysignl_test copysignl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
copysignl_test.cpp copysignl_test.cpp
HDRS HDRS
CopySignTest.h CopySignTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.copysignl libc.src.math.copysignl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
frexp_test frexp_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexp_test.cpp frexp_test.cpp
HDRS HDRS
FrexpTest.h FrexpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexp libc.src.math.frexp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
frexpf_test frexpf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexpf_test.cpp frexpf_test.cpp
HDRS HDRS
FrexpTest.h FrexpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexpf libc.src.math.frexpf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
frexpl_test frexpl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
frexpl_test.cpp frexpl_test.cpp
HDRS HDRS
FrexpTest.h FrexpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.frexpl libc.src.math.frexpl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ilogb_test ilogb_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ilogb_test.cpp ilogb_test.cpp
HDRS HDRS
ILogbTest.h ILogbTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ilogb libc.src.math.ilogb
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ilogbf_test ilogbf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ilogbf_test.cpp ilogbf_test.cpp
HDRS HDRS
ILogbTest.h ILogbTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ilogbf libc.src.math.ilogbf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ilogbl_test ilogbl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ilogbl_test.cpp ilogbl_test.cpp
HDRS HDRS
ILogbTest.h ILogbTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ilogbl libc.src.math.ilogbl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ldexp_test ldexp_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ldexp_test.cpp ldexp_test.cpp
HDRS HDRS
LdExpTest.h LdExpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ldexp libc.src.math.ldexp
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ldexpf_test ldexpf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ldexpf_test.cpp ldexpf_test.cpp
HDRS HDRS
LdExpTest.h LdExpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ldexpf libc.src.math.ldexpf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ldexpl_test ldexpl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
ldexpl_test.cpp ldexpl_test.cpp
HDRS HDRS
LdExpTest.h LdExpTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.ldexpl libc.src.math.ldexpl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
logb_test logb_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logb_test.cpp logb_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logb libc.src.math.logb
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
logbf_test logbf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logbf_test.cpp logbf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logbf libc.src.math.logbf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
logbl_test logbl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
logbl_test.cpp logbl_test.cpp
HDRS HDRS
LogbTest.h LogbTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.logbl libc.src.math.logbl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
modf_test modf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modf_test.cpp modf_test.cpp
HDRS HDRS
ModfTest.h ModfTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modf libc.src.math.modf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
modff_test modff_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modff_test.cpp modff_test.cpp
HDRS HDRS
ModfTest.h ModfTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modff libc.src.math.modff
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
modfl_test modfl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
modfl_test.cpp modfl_test.cpp
HDRS HDRS
ModfTest.h ModfTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.modfl libc.src.math.modfl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fdimf_test fdimf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fdimf_test.cpp fdimf_test.cpp
HDRS HDRS
FDimTest.h FDimTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fdimf libc.src.math.fdimf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fdim_test fdim_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fdim_test.cpp fdim_test.cpp
HDRS HDRS
FDimTest.h FDimTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fdim libc.src.math.fdim
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fdiml_test fdiml_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fdiml_test.cpp fdiml_test.cpp
HDRS HDRS
FDimTest.h FDimTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fdiml libc.src.math.fdiml
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fminf_test fminf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fminf_test.cpp fminf_test.cpp
HDRS HDRS
FMinTest.h FMinTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fminf libc.src.math.fminf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fmin_test fmin_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmin_test.cpp fmin_test.cpp
HDRS HDRS
FMinTest.h FMinTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmin libc.src.math.fmin
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fminl_test fminl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fminl_test.cpp fminl_test.cpp
HDRS HDRS
FMinTest.h FMinTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fminl libc.src.math.fminl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fmaxf_test fmaxf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmaxf_test.cpp fmaxf_test.cpp
HDRS HDRS
FMaxTest.h FMaxTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmaxf libc.src.math.fmaxf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fmax_test fmax_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmax_test.cpp fmax_test.cpp
HDRS HDRS
FMaxTest.h FMaxTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmax libc.src.math.fmax
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fmaxl_test fmaxl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmaxl_test.cpp fmaxl_test.cpp
HDRS HDRS
FMaxTest.h FMaxTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmaxl libc.src.math.fmaxl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sqrtf_test sqrtf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sqrtf_test.cpp sqrtf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.sqrtf libc.src.math.sqrtf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sqrt_test sqrt_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sqrt_test.cpp sqrt_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.sqrt libc.src.math.sqrt
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
# The quad precision test for sqrt against MPFR currently suffers # The quad precision test for sqrt against MPFR currently suffers
# from insufficient precision in MPFR calculations leading to # from insufficient precision in MPFR calculations leading to
# https://hal.archives-ouvertes.fr/hal-01091186/document. We will # https://hal.archives-ouvertes.fr/hal-01091186/document. We will
# renable after fixing the precision issue. # renable after fixing the precision issue.
if(${LIBC_TARGET_ARCHITECTURE_IS_X86}) if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
add_fp_unittest( add_fp_unittest(
sqrtl_test sqrtl_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
sqrtl_test.cpp sqrtl_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.sqrtl libc.src.math.sqrtl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
else() else()
message(STATUS "Skipping sqrtl_test") message(STATUS "Skipping sqrtl_test")
endif() endif()
add_fp_unittest( add_fp_unittest(
remquof_test remquof_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquof_test.cpp remquof_test.cpp
HDRS HDRS
RemQuoTest.h RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquof libc.src.math.remquof
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
remquo_test remquo_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquo_test.cpp remquo_test.cpp
HDRS HDRS
RemQuoTest.h RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquo libc.src.math.remquo
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
remquol_test remquol_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquol_test.cpp remquol_test.cpp
HDRS HDRS
RemQuoTest.h RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquol libc.src.math.remquol
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
hypotf_test hypotf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
hypotf_test.cpp hypotf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.hypotf libc.src.math.hypotf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
hypot_test hypot_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
hypot_test.cpp hypot_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.hypot libc.src.math.hypot
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
nextafter_test nextafter_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
nextafter_test.cpp nextafter_test.cpp
HDRS HDRS
NextAfterTest.h NextAfterTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.nextafter libc.src.math.nextafter
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
nextafterf_test nextafterf_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
nextafterf_test.cpp nextafterf_test.cpp
HDRS HDRS
NextAfterTest.h NextAfterTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.nextafterf libc.src.math.nextafterf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
nextafterl_test nextafterl_test
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
nextafterl_test.cpp nextafterl_test.cpp
HDRS HDRS
NextAfterTest.h NextAfterTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.nextafterl libc.src.math.nextafterl
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fmaf_test fmaf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fmaf_test.cpp fmaf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fmaf libc.src.math.fmaf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
fma_test fma_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
fma_test.cpp fma_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.fma libc.src.math.fma
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
tan_test tan_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
tan_test.cpp tan_test.cpp
DEPENDS DEPENDS
libc.src.math.tan libc.src.math.tan
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
expm1f_test expm1f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expm1f_test.cpp expm1f_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
libc.include.math libc.include.math
libc.src.math.expm1f libc.src.math.expm1f
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_subdirectory(generic) add_subdirectory(generic)
add_subdirectory(exhaustive) add_subdirectory(exhaustive)
add_subdirectory(differential_testing) add_subdirectory(differential_testing)

libc/test/src/math/CeilTest.h

//===-- Utility class to test ceil[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test ceil[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class CeilTest : public __llvm_libc::testing::Test { template <typename T> class CeilTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libc/test/src/math/CopySignTest.h

//===-- Utility class to test copysign[f|l] ---------------------*- C++ -*-===// //===-- Utility class to test copysign[f|l] ---------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class CopySignTest : public __llvm_libc::testing::Test { template <typename T> class CopySignTest : public __llvm_libc::testing::Test {
Show All 38 Lines

libc/test/src/math/FAbsTest.h

//===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FAbsTest : public __llvm_libc::testing::Test { template <typename T> class FAbsTest : public __llvm_libc::testing::Test {
Show All 32 Lines

libc/test/src/math/FDimTest.h

//===-- Utility class to test different flavors of fdim ---------*- C++ -*-===// //===-- Utility class to test different flavors of fdim ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "utils/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
template <typename T> template <typename T>
class FDimTestTemplate : public __llvm_libc::testing::Test { class FDimTestTemplate : public __llvm_libc::testing::Test {
public: public:
using FuncPtr = T (*)(T, T); using FuncPtr = T (*)(T, T);
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

libc/test/src/math/FMaxTest.h

//===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FMaxTest : public __llvm_libc::testing::Test { template <typename T> class FMaxTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libc/test/src/math/FMinTest.h

//===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FMinTest : public __llvm_libc::testing::Test { template <typename T> class FMinTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

libc/test/src/math/FloorTest.h

//===-- Utility class to test floor[f|l] ------------------------*- C++ -*-===// //===-- Utility class to test floor[f|l] ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FloorTest : public __llvm_libc::testing::Test { template <typename T> class FloorTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libc/test/src/math/FmaTest.h

//===-- Utility class to test different flavors of fma --------------------===// //===-- Utility class to test different flavors of fma --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_FMATEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_FMATEST_H
#define LLVM_LIBC_TEST_SRC_MATH_FMATEST_H #define LLVM_LIBC_TEST_SRC_MATH_FMATEST_H
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include "utils/testutils/RandUtils.h" #include "utils/testutils/RandUtils.h"
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
class FmaTestTemplate : public __llvm_libc::testing::Test { class FmaTestTemplate : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libc/test/src/math/FrexpTest.h

//===-- Utility class to test frexp[f|l] ------------------------*- C++ -*-===// //===-- Utility class to test frexp[f|l] ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class FrexpTest : public __llvm_libc::testing::Test { template <typename T> class FrexpTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

libc/test/src/math/HypotTest.h

//===-- Utility class to test different flavors of hypot ------------------===// //===-- Utility class to test different flavors of hypot ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_HYPOTTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_HYPOTTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_HYPOTTEST_H #define LLVM_LIBC_TEST_SRC_MATH_HYPOTTEST_H
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/Hypot.h" #include "src/__support/FPUtil/Hypot.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libc/test/src/math/ILogbTest.h

//===-- Utility class to test different flavors of ilogb --------*- C++ -*-===// //===-- Utility class to test different flavors of ilogb --------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H #define LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <limits.h> #include <limits.h>
class LlvmLibcILogbTest : public __llvm_libc::testing::Test { class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
public: public:
template <typename T> struct ILogbFunc { typedef int (*Func)(T); }; template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

libc/test/src/math/LdExpTest.h

//===-- Utility class to test different flavors of ldexp --------*- C++ -*-===// //===-- Utility class to test different flavors of ldexp --------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H #define LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/NormalFloat.h" #include "src/__support/FPUtil/NormalFloat.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <limits.h> #include <limits.h>
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
template <typename T> template <typename T>
class LdExpTestTemplate : public __llvm_libc::testing::Test { class LdExpTestTemplate : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

libc/test/src/math/LogbTest.h

//===-- Utility class to test logb[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test logb[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class LogbTest : public __llvm_libc::testing::Test { template <typename T> class LogbTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libc/test/src/math/ModfTest.h

//===-- Utility class to test floor[f|l] ------------------------*- C++ -*-===// //===-- Utility class to test floor[f|l] ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "utils/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class ModfTest : public __llvm_libc::testing::Test { template <typename T> class ModfTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

libc/test/src/math/NextAfterTest.h

//===-- Utility class to test different flavors of nextafter ----*- C++ -*-===// //===-- Utility class to test different flavors of nextafter ----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H #define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "utils/CPP/TypeTraits.h" #include "utils/CPP/TypeTraits.h"
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
template <typename T> template <typename T>
class NextAfterTestTemplate : public __llvm_libc::testing::Test { class NextAfterTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>; using FPBits = __llvm_libc::fputil::FPBits<T>;
using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>; using MantissaWidth = __llvm_libc::fputil::MantissaWidth<T>;
using UIntType = typename FPBits::UIntType; using UIntType = typename FPBits::UIntType;
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

libc/test/src/math/RIntTest.h

//===-- Utility class to test different flavors of rint ---------*- C++ -*-===// //===-- Utility class to test different flavors of rint ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H #define LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <fenv.h> #include <fenv.h>
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

libc/test/src/math/RemQuoTest.h

//===-- Utility class to test different flavors of remquo -------*- C++ -*-===// //===-- Utility class to test different flavors of remquo -------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H #define LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H
#include "utils/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> template <typename T>
class RemQuoTestTemplate : public __llvm_libc::testing::Test { class RemQuoTestTemplate : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

libc/test/src/math/RoundTest.h

//===-- Utility class to test round[f|l] ------------------------*- C++ -*-===// //===-- Utility class to test round[f|l] ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class RoundTest : public __llvm_libc::testing::Test { template <typename T> class RoundTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libc/test/src/math/RoundToIntegerTest.h

//===-- Utility class to test different flavors of [l|ll]round --*- C++ -*-===// //===-- Utility class to test different flavors of [l|ll]round --*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H #ifndef LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H #define LLVM_LIBC_TEST_SRC_MATH_ROUNDTOINTEGERTEST_H
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#if math_errhandling & MATH_ERRNO #if math_errhandling & MATH_ERRNO
#include <errno.h> #include <errno.h>
#endif #endif
#if math_errhandling & MATH_ERREXCEPT #if math_errhandling & MATH_ERREXCEPT
#include "utils/FPUtil/FEnvUtils.h" #include "src/__support/FPUtil/FEnvUtils.h"
#endif #endif
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO, static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
FE_TONEAREST}; FE_TONEAREST};
template <typename F, typename I, bool TestModes = false> template <typename F, typename I, bool TestModes = false>
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

libc/test/src/math/SqrtTest.h

//===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===// //===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class SqrtTest : public __llvm_libc::testing::Test { template <typename T> class SqrtTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libc/test/src/math/TruncTest.h

//===-- Utility class to test trunc[f|l] ------------------------*- C++ -*-===// //===-- Utility class to test trunc[f|l] ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/TestHelpers.h" #include "src/__support/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T> class TruncTest : public __llvm_libc::testing::Test { template <typename T> class TruncTest : public __llvm_libc::testing::Test {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

libc/test/src/math/cos_test.cpp

//===-- Unittests for cos -------------------------------------------------===// //===-- Unittests for cos -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/cos.h" #include "src/math/cos.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
Show All 14 Lines

libc/test/src/math/cosf_test.cpp

//===-- Unittests for cosf ------------------------------------------------===// //===-- Unittests for cosf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/cosf.h" #include "src/math/cosf.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/CPP/Array.h" #include "utils/CPP/Array.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::sdcomp26094Values;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libc/test/src/math/differential_testing/CMakeLists.txt

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines target_link_libraries(
${fq_target_name} ${fq_target_name}
PRIVATE ${link_object_files} libc_test_utils) PRIVATE ${link_object_files} libc_test_utils)
set_target_properties(${fq_target_name} set_target_properties(${fq_target_name}
PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
add_dependencies( add_dependencies(
${fq_target_name} ${fq_target_name}
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
${fq_deps_list} ${fq_deps_list}
) )
endfunction() endfunction()
add_header_library( add_header_library(
single_input_single_output_diff single_input_single_output_diff
HDRS HDRS
SingleInputSingleOutputDiff.h SingleInputSingleOutputDiff.h
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h

//===-- Common utility class for differential analysis --------------------===// //===-- Common utility class for differential analysis --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/testutils/StreamWrapper.h" #include "utils/testutils/StreamWrapper.h"
#include "utils/testutils/Timer.h" #include "utils/testutils/Timer.h"
namespace __llvm_libc { namespace __llvm_libc {
namespace testing { namespace testing {
template <typename T> class SingleInputSingleOutputDiff { template <typename T> class SingleInputSingleOutputDiff {
using FPBits = fputil::FPBits<T>; using FPBits = fputil::FPBits<T>;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libc/test/src/math/exhaustive/CMakeLists.txt

add_libc_exhaustive_testsuite(libc_math_exhaustive_tests) add_libc_exhaustive_testsuite(libc_math_exhaustive_tests)
add_fp_unittest( add_fp_unittest(
sqrtf_test sqrtf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_exhaustive_tests libc_math_exhaustive_tests
SRCS SRCS
sqrtf_test.cpp sqrtf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.sqrtf libc.src.math.sqrtf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
sinf_test sinf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_exhaustive_tests libc_math_exhaustive_tests
SRCS SRCS
sinf_test.cpp sinf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.sinf libc.src.math.sinf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
cosf_test cosf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_exhaustive_tests libc_math_exhaustive_tests
SRCS SRCS
cosf_test.cpp cosf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.cosf libc.src.math.cosf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
expm1f_test expm1f_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_exhaustive_tests libc_math_exhaustive_tests
SRCS SRCS
expm1f_test.cpp expm1f_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.expm1f libc.src.math.expm1f
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )

libc/test/src/math/exhaustive/cosf_test.cpp

//===-- Exhaustive test for cosf ------------------------------------------===// //===-- Exhaustive test for cosf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/cosf.h" #include "src/math/cosf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibccosffExhaustiveTest, AllValues) { TEST(LlvmLibccosffExhaustiveTest, AllValues) {
uint32_t bits = 0; uint32_t bits = 0;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cosf(x), 1.0);
} while (bits++ < 0xffff'ffffU); } while (bits++ < 0xffff'ffffU);
} }

libc/test/src/math/exhaustive/expm1f_test.cpp

//===-- Exhaustive test for expm1f-----------------------------------------===// //===-- Exhaustive test for expm1f-----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/expm1f.h" #include "src/math/expm1f.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibcExpm1fExhaustiveTest, AllValues) { TEST(LlvmLibcExpm1fExhaustiveTest, AllValues) {
Show All 9 Lines

libc/test/src/math/exhaustive/sinf_test.cpp

//===-- Exhaustive test for sinf ------------------------------------------===// //===-- Exhaustive test for sinf ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/sinf.h" #include "src/math/sinf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibcsinffExhaustiveTest, AllValues) { TEST(LlvmLibcsinffExhaustiveTest, AllValues) {
uint32_t bits = 0; uint32_t bits = 0;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0); ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sinf(x), 1.0);
} while (bits++ < 0xffff'ffffU); } while (bits++ < 0xffff'ffffU);
} }

libc/test/src/math/exhaustive/sqrtf_test.cpp

//===-- Exhaustive test for sqrtf -----------------------------------------===// //===-- Exhaustive test for sqrtf -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/sqrtf.h" #include "src/math/sqrtf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>; using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
TEST(LlvmLibcSqrtfExhaustiveTest, AllValues) { TEST(LlvmLibcSqrtfExhaustiveTest, AllValues) {
uint32_t bits = 0; uint32_t bits = 0;
do { do {
FPBits xbits(bits); FPBits xbits(bits);
float x = float(xbits); float x = float(xbits);
ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, __llvm_libc::sqrtf(x), 0.5); ASSERT_MPFR_MATCH(mpfr::Operation::Sqrt, x, __llvm_libc::sqrtf(x), 0.5);
} while (bits++ < 0xffff'ffffU); } while (bits++ < 0xffff'ffffU);
} }

libc/test/src/math/exp2f_test.cpp

//===-- Unittests for exp2f -----------------------------------------------===// //===-- Unittests for exp2f -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/exp2f.h" #include "src/math/exp2f.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libc/test/src/math/expf_test.cpp

//===-- Unittests for expf ------------------------------------------------===// //===-- Unittests for expf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/expf.h" #include "src/math/expf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

libc/test/src/math/expm1f_test.cpp

//===-- Unittests for expm1f-----------------------------------------------===// //===-- Unittests for expm1f-----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/expm1f.h" #include "src/math/expm1f.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

libc/test/src/math/fdim_test.cpp

//===-- Unittests for fdim ------------------------------------------------===// //===-- Unittests for fdim ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FDimTest.h" #include "FDimTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/fdim.h" #include "src/math/fdim.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<double>; using LlvmLibcFDimTest = FDimTestTemplate<double>;
TEST_F(LlvmLibcFDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); } TEST_F(LlvmLibcFDimTest, NaNArg_fdim) { testNaNArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); } TEST_F(LlvmLibcFDimTest, InfArg_fdim) { testInfArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); } TEST_F(LlvmLibcFDimTest, NegInfArg_fdim) { testNegInfArg(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); } TEST_F(LlvmLibcFDimTest, BothZero_fdim) { testBothZero(&__llvm_libc::fdim); }
TEST_F(LlvmLibcFDimTest, InDoubleRange_fdim) { TEST_F(LlvmLibcFDimTest, InDoubleRange_fdim) {
testInRange(&__llvm_libc::fdim); testInRange(&__llvm_libc::fdim);
} }

libc/test/src/math/fdimf_test.cpp

//===-- Unittests for fdimf -----------------------------------------------===// //===-- Unittests for fdimf -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FDimTest.h" #include "FDimTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/fdimf.h" #include "src/math/fdimf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<float>; using LlvmLibcFDimTest = FDimTestTemplate<float>;
TEST_F(LlvmLibcFDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); } TEST_F(LlvmLibcFDimTest, NaNArg_fdimf) { testNaNArg(&__llvm_libc::fdimf); }
TEST_F(LlvmLibcFDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); } TEST_F(LlvmLibcFDimTest, InfArg_fdimf) { testInfArg(&__llvm_libc::fdimf); }
Show All 10 Lines

libc/test/src/math/fdiml_test.cpp

//===-- Unittests for fdiml -----------------------------------------------===// //===-- Unittests for fdiml -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FDimTest.h" #include "FDimTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/fdiml.h" #include "src/math/fdiml.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using LlvmLibcFDimTest = FDimTestTemplate<long double>; using LlvmLibcFDimTest = FDimTestTemplate<long double>;
TEST_F(LlvmLibcFDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); } TEST_F(LlvmLibcFDimTest, NaNArg_fdiml) { testNaNArg(&__llvm_libc::fdiml); }
TEST_F(LlvmLibcFDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); } TEST_F(LlvmLibcFDimTest, InfArg_fdiml) { testInfArg(&__llvm_libc::fdiml); }
Show All 10 Lines

libc/test/src/math/generic/CMakeLists.txt

add_fp_unittest( add_fp_unittest(
ceil_test ceil_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
../ceil_test.cpp ../ceil_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.generic.ceil libc.src.math.generic.ceil
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ceilf_test ceilf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
../ceilf_test.cpp ../ceilf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.generic.ceilf libc.src.math.generic.ceilf
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
ceill_test ceill_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
../ceill_test.cpp ../ceill_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.generic.ceill libc.src.math.generic.ceill
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )

libc/test/src/math/ilogb_test.cpp

//===-- Unittests for ilogb -----------------------------------------------===// //===-- Unittests for ilogb -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ILogbTest.h" #include "ILogbTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/ilogb.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 "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogb) {
testSpecialNumbers<double>(&__llvm_libc::ilogb); testSpecialNumbers<double>(&__llvm_libc::ilogb);
} }
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) { TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogb) {
Show All 14 Lines

libc/test/src/math/ilogbf_test.cpp

//===-- Unittests for ilogbf ----------------------------------------------===// //===-- Unittests for ilogbf ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ILogbTest.h" #include "ILogbTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/ilogbf.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 "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbf) {
testSpecialNumbers<float>(&__llvm_libc::ilogbf); testSpecialNumbers<float>(&__llvm_libc::ilogbf);
} }
TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) { TEST_F(LlvmLibcILogbTest, PowersOfTwo_ilogbf) {
Show All 14 Lines

libc/test/src/math/ilogbl_test.cpp

//===-- Unittests for ilogbl ----------------------------------------------===// //===-- Unittests for ilogbl ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ILogbTest.h" #include "ILogbTest.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/ilogbl.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 "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using RunContext = __llvm_libc::testing::RunContext; using RunContext = __llvm_libc::testing::RunContext;
TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) { TEST_F(LlvmLibcILogbTest, SpecialNumbers_ilogbl) {
testSpecialNumbers<long double>(&__llvm_libc::ilogbl); testSpecialNumbers<long double>(&__llvm_libc::ilogbl);
} }
Show All 16 Lines

libc/test/src/math/sin_test.cpp

//===-- Unittests for sin -------------------------------------------------===// //===-- Unittests for sin -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/sin.h" #include "src/math/sin.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
Show All 14 Lines

libc/test/src/math/sincosf_test.cpp

//===-- Unittests for sincosf ---------------------------------------------===// //===-- Unittests for sincosf ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/sincosf.h" #include "src/math/sincosf.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/CPP/Array.h" #include "utils/CPP/Array.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::sdcomp26094Values;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libc/test/src/math/sinf_test.cpp

//===-- Unittests for sinf ------------------------------------------------===// //===-- Unittests for sinf ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/sinf.h" #include "src/math/sinf.h"
#include "test/src/math/sdcomp26094.h" #include "test/src/math/sdcomp26094.h"
#include "utils/CPP/Array.h" #include "utils/CPP/Array.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
using __llvm_libc::testing::sdcomp26094Values; using __llvm_libc::testing::sdcomp26094Values;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

libc/test/src/math/tan_test.cpp

//===-- Unittests for tan -------------------------------------------------===// //===-- Unittests for tan -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/TestHelpers.h"
#include "src/math/tan.h" #include "src/math/tan.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h" #include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr; namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double) DECLARE_SPECIAL_CONSTANTS(double)
Show All 14 Lines

libc/test/utils/FPUtil/CMakeLists.txt

if((${LIBC_TARGET_OS} STREQUAL "linux") AND (${LIBC_TARGET_ARCHITECTURE_IS_X86})) if((${LIBC_TARGET_OS} STREQUAL "linux") AND (${LIBC_TARGET_ARCHITECTURE_IS_X86}))
add_libc_unittest( add_libc_unittest(
x86_long_double_test x86_long_double_test
SRCS SRCS
x86_long_double_test.cpp x86_long_double_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.utils.FPUtil.fputil libc.src.__support.FPUtil.fputil
) )
endif() endif()

libc/test/utils/FPUtil/x86_long_double_test.cpp

//===-- Unittests for x86 long double -------------------------------------===// //===-- Unittests for x86 long double -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "utils/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <math.h> #include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<long double>; using FPBits = __llvm_libc::fputil::FPBits<long double>;
TEST(X86LongDoubleTest, isNaN) { TEST(X86LongDoubleTest, isNaN) {
// In the nan checks below, we use the macro isnan from math.h to ensure that // In the nan checks below, we use the macro isnan from math.h to ensure that
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

libc/utils/CMakeLists.txt

add_subdirectory(CPP) add_subdirectory(CPP)
add_subdirectory(FPUtil)
add_subdirectory(MPFRWrapper) add_subdirectory(MPFRWrapper)
add_subdirectory(testutils) add_subdirectory(testutils)
add_subdirectory(UnitTest) add_subdirectory(UnitTest)
if(LLVM_LIBC_FULL_BUILD) if(LLVM_LIBC_FULL_BUILD)
add_subdirectory(tools) add_subdirectory(tools)
endif() endif()

libc/utils/FPUtil/BasicOperations.h

  • This file was moved to libc/src/__support/FPUtil/BasicOperations.h.

libc/utils/FPUtil/CMakeLists.txt

  • This file was moved to libc/src/__support/FPUtil/CMakeLists.txt.

libc/utils/FPUtil/DivisionAndRemainderOperations.h

  • This file was moved to libc/src/__support/FPUtil/DivisionAndRemainderOperations.h.

libc/utils/FPUtil/DummyFEnvImpl.h

  • This file was moved to libc/src/__support/FPUtil/DummyFEnvImpl.h.

libc/utils/FPUtil/FEnvUtils.h

  • This file was moved to libc/src/__support/FPUtil/FEnvUtils.h.

libc/utils/FPUtil/FMA.h

  • This file was moved to libc/src/__support/FPUtil/FMA.h.

libc/utils/FPUtil/FPBits.h

  • This file was moved to libc/src/__support/FPUtil/FPBits.h.

libc/utils/FPUtil/FPExceptMatcher.h

  • This file was moved to libc/src/__support/FPUtil/FPExceptMatcher.h.

libc/utils/FPUtil/FPExceptMatcher.cpp

  • This file was moved to libc/src/__support/FPUtil/FPExceptMatcher.cpp.

libc/utils/FPUtil/FloatProperties.h

  • This file was moved to libc/src/__support/FPUtil/FloatProperties.h.

libc/utils/FPUtil/Hypot.h

  • This file was moved to libc/src/__support/FPUtil/Hypot.h.

libc/utils/FPUtil/LongDoubleBitsX86.h

  • This file was moved to libc/src/__support/FPUtil/LongDoubleBitsX86.h.

libc/utils/FPUtil/ManipulationFunctions.h

  • This file was moved to libc/src/__support/FPUtil/ManipulationFunctions.h.

libc/utils/FPUtil/NearestIntegerOperations.h

  • This file was moved to libc/src/__support/FPUtil/NearestIntegerOperations.h.

libc/utils/FPUtil/NextAfterLongDoubleX86.h

  • This file was moved to libc/src/__support/FPUtil/NextAfterLongDoubleX86.h.

libc/utils/FPUtil/NormalFloat.h

  • This file was moved to libc/src/__support/FPUtil/NormalFloat.h.

libc/utils/FPUtil/PlatformDefs.h

  • This file was moved to libc/src/__support/FPUtil/PlatformDefs.h.

libc/utils/FPUtil/PolyEval.h

  • This file was moved to libc/src/__support/FPUtil/PolyEval.h.

libc/utils/FPUtil/Sqrt.h

  • This file was moved to libc/src/__support/FPUtil/Sqrt.h.

libc/utils/FPUtil/SqrtLongDoubleX86.h

  • This file was moved to libc/src/__support/FPUtil/SqrtLongDoubleX86.h.

libc/utils/FPUtil/TestHelpers.h

  • This file was moved to libc/src/__support/FPUtil/TestHelpers.h.

libc/utils/FPUtil/TestHelpers.cpp

  • This file was moved to libc/src/__support/FPUtil/TestHelpers.cpp.

libc/utils/FPUtil/aarch64/FEnvImpl.h

  • This file was moved to libc/src/__support/FPUtil/aarch64/FEnvImpl.h.

libc/utils/FPUtil/aarch64/FMA.h

  • This file was moved to libc/src/__support/FPUtil/aarch64/FMA.h.

libc/utils/FPUtil/generic/FMA.h

  • This file was moved to libc/src/__support/FPUtil/generic/FMA.h.

libc/utils/FPUtil/generic/README.md

  • This file was moved to libc/src/__support/FPUtil/generic/README.md.

libc/utils/FPUtil/x86_64/FEnvImpl.h

  • This file was moved to libc/src/__support/FPUtil/x86_64/FEnvImpl.h.

libc/utils/FPUtil/x86_64/FMA.h

  • This file was moved to libc/src/__support/FPUtil/x86_64/FMA.h.

libc/utils/MPFRWrapper/CMakeLists.txt

if(LIBC_TESTS_CAN_USE_MPFR) if(LIBC_TESTS_CAN_USE_MPFR)
add_library(libcMPFRWrapper add_library(libcMPFRWrapper
MPFRUtils.cpp MPFRUtils.cpp
MPFRUtils.h MPFRUtils.h
) )
add_dependencies(libcMPFRWrapper libc.utils.CPP.standalone_cpp libc.utils.FPUtil.fputil LibcUnitTest) add_dependencies(libcMPFRWrapper libc.utils.CPP.standalone_cpp libc.src.__support.FPUtil.fputil LibcUnitTest)
if(EXISTS ${LLVM_LIBC_MPFR_INSTALL_PATH}) if(EXISTS ${LLVM_LIBC_MPFR_INSTALL_PATH})
target_include_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/include) target_include_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/include)
target_link_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/lib) target_link_directories(libcMPFRWrapper PUBLIC ${LLVM_LIBC_MPFR_INSTALL_PATH}/lib)
endif() endif()
target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp) target_link_libraries(libcMPFRWrapper LibcFPTestHelpers LibcUnitTest mpfr gmp)
else() else()
message(WARNING "Math tests using MPFR will be skipped.") message(WARNING "Math tests using MPFR will be skipped.")
endif() endif()

libc/utils/MPFRWrapper/MPFRUtils.cpp

//===-- Utils which wrap MPFR ---------------------------------------------===// //===-- Utils which wrap MPFR ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MPFRUtils.h" #include "MPFRUtils.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/TestHelpers.h"
#include "utils/CPP/StringView.h" #include "utils/CPP/StringView.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include <cmath> #include <cmath>
#include <memory> #include <memory>
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
#ifdef CUSTOM_MPFR_INCLUDER #ifdef CUSTOM_MPFR_INCLUDER
// Some downstream repos are monoliths carrying MPFR sources in their third // Some downstream repos are monoliths carrying MPFR sources in their third
▲ Show 20 Lines • Show All 747 Lines • Show Last 20 Lines