HDRS
FEnvImpl.h
DEPENDS
- libc.include.errno
libc.include.fenv
libc.include.math
libc.src.__support.macros.attributes
libc.src.__support.CPP.type_traits
libc.src.__support.common
libc.include.math
- libc.include.errno
libc.src.errno.errno
)
libc.src.__support.common
libc.src.__support.macros.optimization
libc.include.math
- libc.include.errno
libc.src.errno.errno
)
#include "src/__support/macros/attributes.h" // LIBC_INLINE
#include "src/__support/macros/properties/architectures.h"
+#include "src/errno/libc_errno.h"
-#include <errno.h>
#include <fenv.h>
#include <math.h>
LIBC_INLINE void set_errno_if_required(int err) {
if (math_errhandling & MATH_ERRNO)
- errno = err;
+ libc_errno = err;
}
} // namespace __llvm_libc::fputil
#include "src/__support/CPP/type_traits.h"
#include "src/__support/common.h"
-#include <errno.h>
#include <math.h>
namespace __llvm_libc {
constexpr I INTEGER_MAX = -(INTEGER_MIN + 1);
FPBits<F> bits(x);
auto set_domain_error_and_raise_invalid = []() {
- if (math_errhandling & MATH_ERRNO)
- errno = EDOM;
- if (math_errhandling & MATH_ERREXCEPT)
- raise_except(FE_INVALID);
+ set_errno_if_required(EDOM);
+ raise_except_if_required(FE_INVALID);
};
if (bits.is_inf_or_nan()) {
HDRS
../log10.h
DEPENDS
+ libc.src.__support.FPUtil.fenv_impl
libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.multiply_add
libc.src.__support.FPUtil.double_double
fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPBits::build_quiet_nan(0);
}
// When 0.5 < |x| <= 1, we perform range reduction as follow:
if (LIBC_UNLIKELY(x < 1.0f)) {
// x < 1.
- fputil::set_except(FE_INVALID);
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
return FPBits_t::build_quiet_nan(0);
}
if (xbits.is_nan()) {
return x;
}
- // |x| == 0
+ // |x| == 1.0
if (x_abs == 0x3F80'0000U) {
- fputil::set_except(FE_DIVBYZERO);
- return with_errno(FPBits::inf(sign).get_val(), ERANGE);
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
+ return FPBits::inf(sign).get_val();
} else {
- fputil::set_except(FE_INVALID);
- return with_errno(
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1)),
- EDOM);
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
+ return FPBits::build_quiet_nan(0);
}
}
fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPBits::build_quiet_nan(0);
}
// Combine the results with the sine of sum formula:
//===----------------------------------------------------------------------===//
#include "src/math/log10.h"
+#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/double_double.h"
#include "src/__support/FPUtil/dyadic_float.h"
xbits.uintval() > FPBits_t::MAX_NORMAL)) {
if (xbits.is_zero()) {
// return -Inf and raise FE_DIVBYZERO.
- return -1.0 / 0.0;
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
+ return static_cast<double>(FPBits_t::neg_inf());
}
if (xbits.get_sign() && !xbits.is_nan()) {
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
return FPBits_t::build_quiet_nan(0);
}
if (xbits.is_inf_or_nan()) {
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) {
// Return -inf and raise FE_DIVBYZERO
- fputil::raise_except(FE_DIVBYZERO);
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf());
}
if (xbits.get_sign() && !xbits.is_nan()) {
// Return NaN and raise FE_INVALID
- fputil::raise_except(FE_INVALID);
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
return FPBits::build_quiet_nan(0);
}
if (xbits.is_inf_or_nan()) {
if (LIBC_UNLIKELY(x_u > FPBits::MAX_NORMAL)) {
if (xbits.get_sign() && !xbits.is_nan()) {
- fputil::raise_except(FE_INVALID);
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
return fputil::FPBits<float>::build_quiet_nan(0);
}
return static_cast<float>(x);
case 0xbd1d20afU: // x = -0x1.3a415ep-5f
return fputil::round_result_slightly_up(-0x1.407112p-5f);
case 0xbf800000U: // x = -1.0
- fputil::raise_except(FE_DIVBYZERO);
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(fputil::FPBits<float>::neg_inf());
#ifndef LIBC_TARGET_CPU_HAS_FMA
case 0x4cc1c80bU: // x = 0x1.839016p+26f
// Exceptional inputs.
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) {
- fputil::raise_except(FE_DIVBYZERO);
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf());
}
if (xbits.get_sign() && !xbits.is_nan()) {
+ fputil::set_errno_if_required(EDOM);
fputil::raise_except(FE_INVALID);
return FPBits::build_quiet_nan(0);
}
if (LIBC_UNLIKELY(x_u < FPBits::MIN_NORMAL || x_u > FPBits::MAX_NORMAL)) {
if (xbits.is_zero()) {
// Return -inf and raise FE_DIVBYZERO
- fputil::raise_except(FE_DIVBYZERO);
+ fputil::set_errno_if_required(ERANGE);
+ fputil::raise_except_if_required(FE_DIVBYZERO);
return static_cast<float>(FPBits::neg_inf());
}
if (xbits.get_sign() && !xbits.is_nan()) {
// Return NaN and raise FE_INVALID
- fputil::raise_except(FE_INVALID);
+ fputil::set_errno_if_required(EDOM);
+ fputil::raise_except_if_required(FE_INVALID);
return FPBits::build_quiet_nan(0);
}
if (xbits.is_inf_or_nan()) {
fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPBits::build_quiet_nan(0);
}
// Combine the results with the sine of sum formula:
fputil::set_errno_if_required(EDOM);
fputil::raise_except_if_required(FE_INVALID);
}
- return x +
- FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+ return x + FPBits::build_quiet_nan(0);
}
// Other large exceptional values
if (auto r = TANF_EXCEPTS.lookup_odd(x_abs, x_sign);
#include "test/UnitTest/Test.h"
#include "utils/testutils/RoundingModeUtils.h"
-#include <errno.h>
#include <math.h>
namespace __llvm_libc {
#define EXPECT_MATH_ERRNO(expected) \
do { \
if (math_errhandling & MATH_ERRNO) { \
- int actual = errno; \
- errno = 0; \
+ int actual = libc_errno; \
+ libc_errno = 0; \
EXPECT_EQ(actual, expected); \
} \
} while (0)
#define ASSERT_MATH_ERRNO(expected) \
do { \
if (math_errhandling & MATH_ERRNO) { \
- int actual = errno; \
- errno = 0; \
+ int actual = libc_errno; \
+ libc_errno = 0; \
ASSERT_EQ(actual, expected); \
} \
} while (0)
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.cosf
libc.src.__support.CPP.array
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.sinf
libc.src.__support.CPP.array
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.sincosf
libc.src.__support.CPP.array
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.tanf
libc.src.__support.CPP.array
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
HDRS
RoundToIntegerTest.h
DEPENDS
- libc.include.errno
libc.include.math
libc.src.errno.errno
libc.src.fenv.feclearexcept
SRCS
expf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.expf
SRCS
exp2f_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.exp2f
SRCS
exp10f_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.exp10f
SRCS
expm1f_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.expm1f
SRCS
logf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.logf
SRCS
log2f_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.log2f
SRCS
log10_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.log10
SRCS
log10f_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.log10f
SRCS
log1pf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.include.math
libc.src.math.log1pf
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.coshf
libc.src.__support.CPP.array
HDRS
sdcomp26094.h
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.sinhf
libc.src.__support.CPP.array
SRCS
atanhf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.atanhf
libc.src.__support.FPUtil.fp_bits
SRCS
asinhf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.asinhf
libc.src.__support.FPUtil.fp_bits
SRCS
acoshf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.acoshf
libc.src.__support.FPUtil.fp_bits
SRCS
asinf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.asinf
libc.src.__support.FPUtil.fp_bits
SRCS
asin_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.asin
)
SRCS
acosf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.acosf
libc.src.__support.FPUtil.fp_bits
SRCS
atanf_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.atanf
libc.src.__support.FPUtil.fp_bits
SRCS
pow_test.cpp
DEPENDS
- libc.include.errno
libc.src.errno.errno
libc.src.math.pow
)
void test_one_input(RoundToIntegerFunc func, F input, I expected,
bool expectError) {
- errno = 0;
+ libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
ASSERT_EQ(func(input), expected);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/acosf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAcosfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/acoshf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAcoshfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(aNaN));
EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(0.0f));
- EXPECT_MATH_ERRNO(0);
+ EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_EQ(0.0f, __llvm_libc::acoshf(1.0f));
EXPECT_MATH_ERRNO(0);
EXPECT_MATH_ERRNO(0);
EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(neg_inf));
- EXPECT_MATH_ERRNO(0);
+ EXPECT_MATH_ERRNO(EDOM);
}
TEST(LlvmLibcAcoshfTest, InFloatRange) {
//
//===----------------------------------------------------------------------===//
+#include "src/errno/libc_errno.h"
#include "src/math/asin.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asin(aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/asinf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/asinhf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAsinhfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::asinhf(aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/atanf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanf(aNaN));
EXPECT_FP_EXCEPTION(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/atanhf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcAtanhfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
__llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(aNaN));
EXPECT_FP_EXCEPTION(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/cosf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCosfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(aNaN));
EXPECT_MATH_ERRNO(0);
#include "src/__support/CPP/array.h"
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/coshf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcCoshfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::coshf(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcCoshfTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::coshf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/exp10f.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExp10fTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::exp10f(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcExp10fTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp10f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
}
TEST(LlvmLibcExp10fTest, Underflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::exp10f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
0x41200000, // x = 10.0f
};
for (int i = 0; i < N; ++i) {
- errno = 0;
+ libc_errno = 0;
float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
__llvm_libc::exp10f(x), 0.5);
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
float result = __llvm_libc::exp10f(x);
// If the computation resulted in an error or did not produce valid result
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/macros/properties/cpu_features.h" // LIBC_TARGET_CPU_HAS_FMA
+#include "src/errno/libc_errno.h"
#include "src/math/exp2f.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExp2fTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcExp2fTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
0xc3150000U, /*-0x1.2ap+7f*/
};
for (int i = 0; i < N; ++i) {
- errno = 0;
+ libc_errno = 0;
float x = float(FPBits(INPUTS[i]));
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
__llvm_libc::exp2f(x), 0.5);
}
TEST(LlvmLibcExp2fTest, Underflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
float result = __llvm_libc::exp2f(x);
// If the computation resulted in an error or did not produce valid result
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/expf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExpfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::expf(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcExpfTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
}
TEST(LlvmLibcExpfTest, Underflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
0.0f, __llvm_libc::expf(float(FPBits(0xff7fffffU))), FE_UNDERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
TEST(LlvmLibcExpfTest, Borderline) {
float x;
- errno = 0;
+ libc_errno = 0;
x = float(FPBits(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
0.5);
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
float result = __llvm_libc::expf(x);
// If the computation resulted in an error or did not produce valid result
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/expm1f.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcExpm1fTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::expm1f(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcExpm1fTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::expm1f(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
}
TEST(LlvmLibcExpm1fTest, Underflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(-1.0f, __llvm_libc::expm1f(float(FPBits(0xff7fffffU))));
float x = float(FPBits(0xc2cffff8U));
TEST(LlvmLibcExpm1fTest, Borderline) {
float x;
- errno = 0;
+ libc_errno = 0;
x = float(FPBits(0x42affff8U));
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
__llvm_libc::expm1f(x), 0.5);
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
float result = __llvm_libc::expm1f(x);
// If the computation resulted in an error or did not produce valid result
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/log10.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
double x = FPBits(v).get_val();
if (isnan(x) || isinf(x) || x < 0.0)
continue;
- errno = 0;
+ libc_errno = 0;
double result = __llvm_libc::log10(x);
++cc;
if (isnan(result))
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/log1pf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
__llvm_libc::log1pf(x), 0.5);
}
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/log2f.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
float x = float(FPBits(v));
if (isnan(x) || isinf(x))
continue;
- errno = 0;
+ libc_errno = 0;
float result = __llvm_libc::log2f(x);
// If the computation resulted in an error or did not produce valid result
// in the single-precision floating point range, then ignore comparing with
//
//===----------------------------------------------------------------------===//
+#include "src/errno/libc_errno.h"
#include "src/math/pow.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(double)
TEST(LlvmLibcAsinTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::pow(aNaN, aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/sincosf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinCosfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
float sin, cos;
__llvm_libc::sincosf(aNaN, &sin, &cos);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/sinf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(aNaN));
EXPECT_MATH_ERRNO(0);
#include "src/__support/CPP/array.h"
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/sinhf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcSinhfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::sinhf(aNaN));
EXPECT_MATH_ERRNO(0);
}
TEST(LlvmLibcSinhfTest, Overflow) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ_WITH_EXCEPTION(
inf, __llvm_libc::sinhf(float(FPBits(0x7f7fffffU))), FE_OVERFLOW);
EXPECT_MATH_ERRNO(ERANGE);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/tanf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(aNaN));
EXPECT_MATH_ERRNO(0);
//===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
#include "src/math/tanhf.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
DECLARE_SPECIAL_CONSTANTS(float)
TEST(LlvmLibcTanhfTest, SpecialNumbers) {
- errno = 0;
+ libc_errno = 0;
EXPECT_FP_EQ(aNaN, __llvm_libc::tanhf(aNaN));
EXPECT_MATH_ERRNO(0);
projects / platform / upstream / llvm.git / commitdiff