caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc][math][c23] Add f16divf C23 math function (#96131)

Browse Source 
Part of #93566.
This commit is contained in:
OverMighty
2024-06-25 14:48:28 +02:00
committed by GitHub
parent abc8c4be3b
commit edbe698ead
20 changed files with 613 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libc/config/linux/aarch64/entrypoints.txt
View File

@@ -505,6 +505,7 @@ if(LIBC_TYPES_HAS_FLOAT16)
libc.src.math.canonicalizef16
libc.src.math.ceilf16
libc.src.math.copysignf16
libc.src.math.f16divf
libc.src.math.f16fmaf
libc.src.math.f16sqrtf
libc.src.math.fabsf16

1
libc/config/linux/x86_64/entrypoints.txt
View File

@@ -536,6 +536,7 @@ if(LIBC_TYPES_HAS_FLOAT16)
libc.src.math.canonicalizef16
libc.src.math.ceilf16
libc.src.math.copysignf16
libc.src.math.f16divf
libc.src.math.f16fmaf
libc.src.math.f16sqrtf
libc.src.math.fabsf16

2
libc/docs/math/index.rst
View File

@@ -124,6 +124,8 @@ Basic Operations
+------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
| dsub | N/A | N/A | | N/A | | 7.12.14.2 | F.10.11 |
+------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
| f16div | |check| | | | N/A | | 7.12.14.4 | F.10.11 |
+------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
| f16fma | |check| | | | N/A | | 7.12.14.5 | F.10.11 |
+------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
| fabs | |check| | |check| | |check| | |check| | |check| | 7.12.7.3 | F.10.4.3 |

2
libc/spec/stdc.td
View File

@@ -726,6 +726,8 @@ def StdC : StandardSpec<"stdc"> {
GuardedFunctionSpec<"setpayloadsigf16", RetValSpec<IntType>, [ArgSpec<Float16Ptr>, ArgSpec<Float16Type>], "LIBC_TYPES_HAS_FLOAT16">,
GuardedFunctionSpec<"f16divf", RetValSpec<Float16Type>, [ArgSpec<FloatType>, ArgSpec<FloatType>], "LIBC_TYPES_HAS_FLOAT16">,
GuardedFunctionSpec<"f16sqrtf", RetValSpec<Float16Type>, [ArgSpec<FloatType>], "LIBC_TYPES_HAS_FLOAT16">,
]
>;

1
libc/src/__support/FPUtil/CMakeLists.txt
View File

@@ -199,6 +199,7 @@ add_header_library(
HDRS
dyadic_float.h
DEPENDS
.fenv_impl
.fp_bits
.multiply_add
libc.src.__support.CPP.type_traits

35
libc/src/__support/FPUtil/dyadic_float.h
View File

@@ -9,6 +9,7 @@
#ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_DYADIC_FLOAT_H
#define LLVM_LIBC_SRC___SUPPORT_FPUTIL_DYADIC_FLOAT_H
#include "FEnvImpl.h"
#include "FPBits.h"
#include "multiply_add.h"
#include "src/__support/CPP/type_traits.h"
@@ -86,11 +87,11 @@ template <size_t Bits> struct DyadicFloat {
// Assume that it is already normalized.
// Output is rounded correctly with respect to the current rounding mode.
template <typename T,
template <typename T, bool ShouldSignalExceptions,
typename = cpp::enable_if_t<cpp::is_floating_point_v<T> &&
(FPBits<T>::FRACTION_LEN < Bits),
void>>
LIBC_INLINE explicit constexpr operator T() const {
LIBC_INLINE constexpr T as() const {
if (LIBC_UNLIKELY(mantissa.is_zero()))
return FPBits<T>::zero(sign).get_val();
@@ -107,7 +108,17 @@ template <size_t Bits> struct DyadicFloat {
T d_hi =
FPBits<T>::create_value(sign, 2 * FPBits<T>::EXP_BIAS, IMPLICIT_MASK)
.get_val();
return T(2) * d_hi;
// volatile prevents constant propagation that would result in infinity
// always being returned no matter the current rounding mode.
volatile T two(2.0);
T r = two * d_hi;
// TODO: Whether rounding down the absolute value to max_normal should
// also raise FE_OVERFLOW and set ERANGE is debatable.
if (ShouldSignalExceptions && FPBits<T>(r).is_inf())
set_errno_if_required(ERANGE);
return r;
}
bool denorm = false;
@@ -179,10 +190,20 @@ template <size_t Bits> struct DyadicFloat {
output_bits_t clear_exp = static_cast<output_bits_t>(
output_bits_t(exp_hi) << FPBits<T>::SIG_LEN);
output_bits_t r_bits = FPBits<T>(r).uintval() - clear_exp;
if (!(r_bits & FPBits<T>::EXP_MASK)) {
// Output is denormal after rounding, clear the implicit bit for 80-bit
// long double.
r_bits -= IMPLICIT_MASK;
// TODO: IEEE Std 754-2019 lets implementers choose whether to check for
// "tininess" before or after rounding for base-2 formats, as long as
// the same choice is made for all operations. Our choice to check after
// rounding might not be the same as the hardware's.
if (ShouldSignalExceptions && round_and_sticky) {
set_errno_if_required(ERANGE);
raise_except_if_required(FE_UNDERFLOW);
}
}
return FPBits<T>(r_bits).get_val();
@@ -191,6 +212,14 @@ template <size_t Bits> struct DyadicFloat {
return r;
}
template <typename T,
typename = cpp::enable_if_t<cpp::is_floating_point_v<T> &&
(FPBits<T>::FRACTION_LEN < Bits),
void>>
LIBC_INLINE explicit constexpr operator T() const {
return as<T, /*ShouldSignalExceptions=*/false>();
}
LIBC_INLINE explicit constexpr operator MantissaType() const {
if (mantissa.is_zero())
return 0;

17
libc/src/__support/FPUtil/generic/CMakeLists.txt
View File

@@ -45,3 +45,20 @@ add_header_library(
libc.src.__support.FPUtil.rounding_mode
libc.src.__support.macros.optimization
)
add_header_library(
div
HDRS
div.h
DEPENDS
libc.hdr.errno_macros
libc.hdr.fenv_macros
libc.src.__support.CPP.bit
libc.src.__support.CPP.type_traits
libc.src.__support.FPUtil.basic_operations
libc.src.__support.FPUtil.fenv_impl
libc.src.__support.FPUtil.fp_bits
libc.src.__support.FPUtil.dyadic_float
libc.src.__support.macros.attributes
libc.src.__support.macros.optimization
)

124
libc/src/__support/FPUtil/generic/div.h Normal file
View File

@@ -0,0 +1,124 @@
//===-- Division of IEEE 754 floating-point numbers -------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_DIV_H
#define LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_DIV_H
#include "hdr/errno_macros.h"
#include "hdr/fenv_macros.h"
#include "src/__support/CPP/bit.h"
#include "src/__support/CPP/type_traits.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/FEnvImpl.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/dyadic_float.h"
#include "src/__support/macros/attributes.h"
#include "src/__support/macros/optimization.h"
namespace LIBC_NAMESPACE::fputil::generic {
template <typename OutType, typename InType>
LIBC_INLINE cpp::enable_if_t<cpp::is_floating_point_v<OutType> &&
cpp::is_floating_point_v<InType> &&
sizeof(OutType) <= sizeof(InType),
OutType>
div(InType x, InType y) {
using OutFPBits = FPBits<OutType>;
using OutStorageType = typename OutFPBits::StorageType;
using InFPBits = FPBits<InType>;
using InStorageType = typename InFPBits::StorageType;
using DyadicFloat =
DyadicFloat<cpp::bit_ceil(static_cast<size_t>(InFPBits::FRACTION_LEN))>;
InFPBits x_bits(x);
InFPBits y_bits(y);
Sign result_sign = x_bits.sign() == y_bits.sign() ? Sign::POS : Sign::NEG;
if (LIBC_UNLIKELY(x_bits.is_inf_or_nan() || y_bits.is_inf_or_nan() ||
x_bits.is_zero() || y_bits.is_zero())) {
if (x_bits.is_nan() || y_bits.is_nan()) {
if (x_bits.is_signaling_nan() || y_bits.is_signaling_nan())
raise_except_if_required(FE_INVALID);
if (x_bits.is_quiet_nan()) {
InStorageType x_payload = static_cast<InStorageType>(getpayload(x));
if ((x_payload & ~(OutFPBits::FRACTION_MASK >> 1)) == 0)
return OutFPBits::quiet_nan(x_bits.sign(),
static_cast<OutStorageType>(x_payload))
.get_val();
}
if (y_bits.is_quiet_nan()) {
InStorageType y_payload = static_cast<InStorageType>(getpayload(y));
if ((y_payload & ~(OutFPBits::FRACTION_MASK >> 1)) == 0)
return OutFPBits::quiet_nan(y_bits.sign(),
static_cast<OutStorageType>(y_payload))
.get_val();
}
return OutFPBits::quiet_nan().get_val();
}
if (x_bits.is_inf()) {
if (y_bits.is_inf()) {
set_errno_if_required(EDOM);
raise_except_if_required(FE_INVALID);
return OutFPBits::quiet_nan().get_val();
}
return OutFPBits::inf(result_sign).get_val();
}
if (y_bits.is_inf())
return OutFPBits::inf(result_sign).get_val();
if (y_bits.is_zero()) {
if (x_bits.is_zero()) {
raise_except_if_required(FE_INVALID);
return OutFPBits::quiet_nan().get_val();
}
raise_except_if_required(FE_DIVBYZERO);
return OutFPBits::inf(result_sign).get_val();
}
if (x_bits.is_zero())
return OutFPBits::zero(result_sign).get_val();
}
DyadicFloat xd(x);
DyadicFloat yd(y);
// Number of iterations = full output precision + 1 rounding bit + 1 potential
// leading 0.
constexpr size_t NUM_ITERS = OutFPBits::FRACTION_LEN + 3;
int result_exp = xd.exponent - yd.exponent - (NUM_ITERS - 1);
InStorageType q = 0;
InStorageType r = static_cast<InStorageType>(xd.mantissa >> 2);
InStorageType yd_mant_in = static_cast<InStorageType>(yd.mantissa >> 1);
for (size_t i = 0; i < NUM_ITERS; ++i) {
q <<= 1;
r <<= 1;
if (r >= yd_mant_in) {
q += 1;
r -= yd_mant_in;
}
}
DyadicFloat result(result_sign, result_exp, q);
result.mantissa += r != 0;
return result.template as<OutType, /*ShouldSignalExceptions=*/true>();
}
} // namespace LIBC_NAMESPACE::fputil::generic
#endif // LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_DIV_H

2
libc/src/math/CMakeLists.txt
View File

@@ -99,6 +99,8 @@ add_math_entrypoint_object(exp10f)
add_math_entrypoint_object(expm1)
add_math_entrypoint_object(expm1f)
add_math_entrypoint_object(f16divf)
add_math_entrypoint_object(f16fmaf)
add_math_entrypoint_object(f16sqrtf)

20
libc/src/math/f16divf.h Normal file
View File

@@ -0,0 +1,20 @@
//===-- Implementation header for f16divf -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_F16DIVF_H
#define LLVM_LIBC_SRC_MATH_F16DIVF_H
#include "src/__support/macros/properties/types.h"
namespace LIBC_NAMESPACE {
float16 f16divf(float x, float y);
} // namespace LIBC_NAMESPACE
#endif // LLVM_LIBC_SRC_MATH_F16DIVF_H

13
libc/src/math/generic/CMakeLists.txt
View File

@@ -3731,6 +3731,19 @@ add_entrypoint_object(
-O3
)
add_entrypoint_object(
f16divf
SRCS
f16divf.cpp
HDRS
../f16divf.h
DEPENDS
libc.src.__support.macros.properties.types
libc.src.__support.FPUtil.generic.div
COMPILE_OPTIONS
-O3
)
add_entrypoint_object(
f16fmaf
SRCS

19
libc/src/math/generic/f16divf.cpp Normal file
View File

@@ -0,0 +1,19 @@
//===-- Implementation of f16divf function --------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "src/math/f16divf.h"
#include "src/__support/FPUtil/generic/div.h"
#include "src/__support/common.h"
namespace LIBC_NAMESPACE {
LLVM_LIBC_FUNCTION(float16, f16divf, (float x, float y)) {
return fputil::generic::div<float16>(x, y);
}
} // namespace LIBC_NAMESPACE

13
libc/test/src/math/CMakeLists.txt
View File

@@ -1890,6 +1890,19 @@ add_fp_unittest(
libc.src.__support.FPUtil.fp_bits
)
add_fp_unittest(
f16divf_test
NEED_MPFR
SUITE
libc-math-unittests
SRCS
f16divf_test.cpp
HDRS
DivTest.h
DEPENDS
libc.src.math.f16divf
)
add_fp_unittest(
f16fmaf_test
NEED_MPFR

74
libc/test/src/math/DivTest.h Normal file
View File

@@ -0,0 +1,74 @@
//===-- Utility class to test different flavors of float div ----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_DIVTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_DIVTEST_H
#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
template <typename OutType, typename InType>
class DivTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
struct InConstants {
DECLARE_SPECIAL_CONSTANTS(InType)
};
using InFPBits = typename InConstants::FPBits;
using InStorageType = typename InConstants::StorageType;
static constexpr InStorageType IN_MAX_NORMAL_U =
InFPBits::max_normal().uintval();
static constexpr InStorageType IN_MIN_NORMAL_U =
InFPBits::min_normal().uintval();
static constexpr InStorageType IN_MAX_SUBNORMAL_U =
InFPBits::max_subnormal().uintval();
static constexpr InStorageType IN_MIN_SUBNORMAL_U =
InFPBits::min_subnormal().uintval();
public:
using DivFunc = OutType (*)(InType, InType);
void test_subnormal_range(DivFunc func) {
constexpr InStorageType COUNT = 100'001;
constexpr InStorageType STEP =
(IN_MAX_SUBNORMAL_U - IN_MIN_SUBNORMAL_U) / COUNT;
for (InStorageType i = 0, v = 0, w = IN_MAX_SUBNORMAL_U; i <= COUNT;
++i, v += STEP, w -= STEP) {
InType x = InFPBits(v).get_val();
InType y = InFPBits(w).get_val();
mpfr::BinaryInput<InType> input{x, y};
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Div, input, func(x, y),
0.5);
}
}
void test_normal_range(DivFunc func) {
constexpr InStorageType COUNT = 100'001;
constexpr InStorageType STEP = (IN_MAX_NORMAL_U - IN_MIN_NORMAL_U) / COUNT;
for (InStorageType i = 0, v = 0, w = IN_MAX_NORMAL_U; i <= COUNT;
++i, v += STEP, w -= STEP) {
InType x = InFPBits(v).get_val();
InType y = InFPBits(w).get_val();
mpfr::BinaryInput<InType> input{x, y};
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Div, input, func(x, y),
0.5);
}
}
};
#define LIST_DIV_TESTS(OutType, InType, func) \
using LlvmLibcDivTest = DivTest<OutType, InType>; \
TEST_F(LlvmLibcDivTest, SubnormalRange) { test_subnormal_range(&func); } \
TEST_F(LlvmLibcDivTest, NormalRange) { test_normal_range(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_DIVTEST_H

13
libc/test/src/math/f16divf_test.cpp Normal file
View File

@@ -0,0 +1,13 @@
//===-- Unittests for f16divf ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "DivTest.h"
#include "src/math/f16divf.h"
LIST_DIV_TESTS(float16, float, LIBC_NAMESPACE::f16divf)

14
libc/test/src/math/smoke/CMakeLists.txt
View File

@@ -3630,6 +3630,20 @@ add_fp_unittest(
libc.src.math.setpayloadsigf16
)
add_fp_unittest(
f16divf_test
SUITE
libc-math-smoke-tests
SRCS
f16divf_test.cpp
HDRS
DivTest.h
DEPENDS
libc.hdr.fenv_macros
libc.src.__support.FPUtil.basic_operations
libc.src.math.f16divf
)
add_fp_unittest(
f16fmaf_test
SUITE

171
libc/test/src/math/smoke/DivTest.h Normal file
View File

@@ -0,0 +1,171 @@
//===-- Utility class to test different flavors of float div --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_DIVTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_DIVTEST_H
#include "hdr/fenv_macros.h"
#include "src/__support/FPUtil/BasicOperations.h"
#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/RoundingModeUtils.h"
#include "test/UnitTest/Test.h"
template <typename OutType, typename InType>
class DivTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
DECLARE_SPECIAL_CONSTANTS(OutType)
struct InConstants {
DECLARE_SPECIAL_CONSTANTS(InType)
};
using InFPBits = typename InConstants::FPBits;
using InStorageType = typename InConstants::StorageType;
public:
using DivFunc = OutType (*)(InType, InType);
void test_special_numbers(DivFunc func) {
EXPECT_FP_IS_NAN(func(aNaN, aNaN));
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(sNaN, sNaN), FE_INVALID);
InType qnan_42 = InFPBits::quiet_nan(Sign::POS, 0x42).get_val();
EXPECT_FP_EQ(InType(0x42.0p+0),
LIBC_NAMESPACE::fputil::getpayload(func(qnan_42, zero)));
EXPECT_FP_EQ(InType(0x42.0p+0),
LIBC_NAMESPACE::fputil::getpayload(func(zero, qnan_42)));
if constexpr (sizeof(OutType) < sizeof(InType)) {
InStorageType max_payload = InFPBits::FRACTION_MASK >> 1;
InType qnan_max = InFPBits::quiet_nan(Sign::POS, max_payload).get_val();
EXPECT_FP_EQ(zero,
LIBC_NAMESPACE::fputil::getpayload(func(qnan_max, zero)));
EXPECT_FP_EQ(zero,
LIBC_NAMESPACE::fputil::getpayload(func(zero, qnan_max)));
EXPECT_FP_EQ(InType(0x42.0p+0),
LIBC_NAMESPACE::fputil::getpayload(func(qnan_max, qnan_42)));
EXPECT_FP_EQ(InType(0x42.0p+0),
LIBC_NAMESPACE::fputil::getpayload(func(qnan_42, qnan_max)));
}
EXPECT_FP_EQ(inf, func(inf, zero));
EXPECT_FP_EQ(neg_inf, func(neg_inf, zero));
EXPECT_FP_EQ(neg_inf, func(inf, neg_zero));
EXPECT_FP_EQ(inf, func(neg_inf, neg_zero));
}
void test_division_by_zero(DivFunc func) {
EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(InType(1.0), zero), FE_DIVBYZERO);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(InType(-1.0), zero),
FE_DIVBYZERO);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(InType(1.0), neg_zero),
FE_DIVBYZERO);
EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(InType(1.0), zero), FE_DIVBYZERO);
}
void test_invalid_operations(DivFunc func) {
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(zero, zero), FE_INVALID);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(neg_zero, zero), FE_INVALID);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(zero, neg_zero), FE_INVALID);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(neg_zero, neg_zero), FE_INVALID);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(inf, inf), FE_INVALID);
EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(neg_inf, inf), FE_INVALID);
EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(inf, neg_inf), FE_INVALID);
EXPECT_MATH_ERRNO(EDOM);
EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(neg_inf, neg_inf), FE_INVALID);
EXPECT_MATH_ERRNO(EDOM);
}
void test_range_errors(DivFunc func) {
using namespace LIBC_NAMESPACE::fputil::testing;
if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(max_normal, min_normal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(-inf, func(neg_max_normal, min_denormal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_zero, func(neg_min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
}
if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
EXPECT_FP_EQ_WITH_EXCEPTION(max_normal, func(max_normal, min_normal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,
func(neg_max_normal, min_denormal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_zero, func(neg_min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
}
if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
EXPECT_FP_EQ_WITH_EXCEPTION(max_normal, func(max_normal, min_normal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_FP_EQ_WITH_EXCEPTION(-inf, func(neg_max_normal, min_denormal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_min_denormal,
func(neg_min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
}
if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(max_normal, min_normal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,
func(neg_max_normal, min_denormal),
FE_OVERFLOW | FE_INEXACT);
EXPECT_FP_EQ_WITH_EXCEPTION(min_denormal, func(min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
EXPECT_FP_EQ_WITH_EXCEPTION(neg_zero, func(neg_min_denormal, max_normal),
FE_UNDERFLOW | FE_INEXACT);
EXPECT_MATH_ERRNO(ERANGE);
}
}
void test_inexact_results(DivFunc func) {
func(InType(1.0), InType(3.0));
EXPECT_FP_EXCEPTION(FE_INEXACT);
}
};
#define LIST_DIV_TESTS(OutType, InType, func) \
using LlvmLibcDivTest = DivTest<OutType, InType>; \
TEST_F(LlvmLibcDivTest, SpecialNumbers) { test_special_numbers(&func); } \
TEST_F(LlvmLibcDivTest, DivisionByZero) { test_division_by_zero(&func); } \
TEST_F(LlvmLibcDivTest, InvalidOperations) { \
test_invalid_operations(&func); \
} \
TEST_F(LlvmLibcDivTest, RangeErrors) { test_range_errors(&func); } \
TEST_F(LlvmLibcDivTest, InexactResults) { test_inexact_results(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_DIVTEST_H

13
libc/test/src/math/smoke/f16divf_test.cpp Normal file
View File

@@ -0,0 +1,13 @@
//===-- Unittests for f16divf ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "DivTest.h"
#include "src/math/f16divf.h"
LIST_DIV_TESTS(float16, float, LIBC_NAMESPACE::f16divf)

84
libc/utils/MPFRWrapper/MPFRUtils.cpp
View File

@@ -296,6 +296,12 @@ public:
return result;
}
MPFRNumber div(const MPFRNumber &b) const {
MPFRNumber result(*this);
mpfr_div(result.value, value, b.value, mpfr_rounding);
return result;
}
MPFRNumber floor() const {
MPFRNumber result(*this);
mpfr_floor(result.value, value);
@@ -708,6 +714,8 @@ binary_operation_one_output(Operation op, InputType x, InputType y,
switch (op) {
case Operation::Atan2:
return inputX.atan2(inputY);
case Operation::Div:
return inputX.div(inputY);
case Operation::Fmod:
return inputX.fmod(inputY);
case Operation::Hypot:
@@ -885,42 +893,47 @@ template void explain_binary_operation_two_outputs_error<long double>(
Operation, const BinaryInput<long double> &,
const BinaryOutput<long double> &, double, RoundingMode);
template <typename T>
void explain_binary_operation_one_output_error(Operation op,
const BinaryInput<T> &input,
T libc_result,
double ulp_tolerance,
RoundingMode rounding) {
unsigned int precision = get_precision<T>(ulp_tolerance);
template <typename InputType, typename OutputType>
void explain_binary_operation_one_output_error(
Operation op, const BinaryInput<InputType> &input, OutputType libc_result,
double ulp_tolerance, RoundingMode rounding) {
unsigned int precision = get_precision<InputType>(ulp_tolerance);
MPFRNumber mpfrX(input.x, precision);
MPFRNumber mpfrY(input.y, precision);
FPBits<T> xbits(input.x);
FPBits<T> ybits(input.y);
FPBits<InputType> xbits(input.x);
FPBits<InputType> ybits(input.y);
MPFRNumber mpfr_result =
binary_operation_one_output(op, input.x, input.y, precision, rounding);
MPFRNumber mpfrMatchValue(libc_result);
tlog << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
tlog << "First input bits: " << str(FPBits<T>(input.x)) << '\n';
tlog << "Second input bits: " << str(FPBits<T>(input.y)) << '\n';
tlog << "First input bits: " << str(FPBits<InputType>(input.x)) << '\n';
tlog << "Second input bits: " << str(FPBits<InputType>(input.y)) << '\n';
tlog << "Libc result: " << mpfrMatchValue.str() << '\n'
<< "MPFR result: " << mpfr_result.str() << '\n';
tlog << "Libc floating point result bits: " << str(FPBits<T>(libc_result))
<< '\n';
tlog << "Libc floating point result bits: "
<< str(FPBits<OutputType>(libc_result)) << '\n';
tlog << " MPFR rounded bits: "
<< str(FPBits<T>(mpfr_result.as<T>())) << '\n';
<< str(FPBits<OutputType>(mpfr_result.as<OutputType>())) << '\n';
tlog << "ULP error: " << mpfr_result.ulp_as_mpfr_number(libc_result).str()
<< '\n';
}
template void explain_binary_operation_one_output_error<float>(
Operation, const BinaryInput<float> &, float, double, RoundingMode);
template void explain_binary_operation_one_output_error<double>(
template void
explain_binary_operation_one_output_error(Operation, const BinaryInput<float> &,
float, double, RoundingMode);
template void explain_binary_operation_one_output_error(
Operation, const BinaryInput<double> &, double, double, RoundingMode);
template void explain_binary_operation_one_output_error<long double>(
Operation, const BinaryInput<long double> &, long double, double,
RoundingMode);
template void
explain_binary_operation_one_output_error(Operation,
const BinaryInput<long double> &,
long double, double, RoundingMode);
#ifdef LIBC_TYPES_HAS_FLOAT16
template void
explain_binary_operation_one_output_error(Operation, const BinaryInput<float> &,
float16, double, RoundingMode);
#endif
template <typename InputType, typename OutputType>
void explain_ternary_operation_one_output_error(
@@ -1051,12 +1064,13 @@ template bool compare_binary_operation_two_outputs<long double>(
Operation, const BinaryInput<long double> &,
const BinaryOutput<long double> &, double, RoundingMode);
template <typename T>
template <typename InputType, typename OutputType>
bool compare_binary_operation_one_output(Operation op,
const BinaryInput<T> &input,
T libc_result, double ulp_tolerance,
const BinaryInput<InputType> &input,
OutputType libc_result,
double ulp_tolerance,
RoundingMode rounding) {
unsigned int precision = get_precision<T>(ulp_tolerance);
unsigned int precision = get_precision<InputType>(ulp_tolerance);
MPFRNumber mpfr_result =
binary_operation_one_output(op, input.x, input.y, precision, rounding);
double ulp = mpfr_result.ulp(libc_result);
@@ -1064,13 +1078,21 @@ bool compare_binary_operation_one_output(Operation op,
return (ulp <= ulp_tolerance);
}
template bool compare_binary_operation_one_output<float>(
Operation, const BinaryInput<float> &, float, double, RoundingMode);
template bool compare_binary_operation_one_output<double>(
Operation, const BinaryInput<double> &, double, double, RoundingMode);
template bool compare_binary_operation_one_output<long double>(
Operation, const BinaryInput<long double> &, long double, double,
RoundingMode);
template bool compare_binary_operation_one_output(Operation,
const BinaryInput<float> &,
float, double, RoundingMode);
template bool compare_binary_operation_one_output(Operation,
const BinaryInput<double> &,
double, double, RoundingMode);
template bool
compare_binary_operation_one_output(Operation, const BinaryInput<long double> &,
long double, double, RoundingMode);
#ifdef LIBC_TYPES_HAS_FLOAT16
template bool compare_binary_operation_one_output(Operation,
const BinaryInput<float> &,
float16, double,
RoundingMode);
#endif
template <typename InputType, typename OutputType>
bool compare_ternary_operation_one_output(Operation op,

39
libc/utils/MPFRWrapper/MPFRUtils.h
View File

@@ -71,6 +71,7 @@ enum class Operation : int {
// output.
BeginBinaryOperationsSingleOutput,
Atan2,
Div,
Fmod,
Hypot,
Pow,
@@ -129,6 +130,14 @@ struct AreMatchingBinaryInputAndBinaryOutput<BinaryInput<T>, BinaryOutput<T>> {
static constexpr bool VALUE = cpp::is_floating_point_v<T>;
};
template <typename T> struct IsBinaryInput {
static constexpr bool VALUE = false;
};
template <typename T> struct IsBinaryInput<BinaryInput<T>> {
static constexpr bool VALUE = true;
};
template <typename T> struct IsTernaryInput {
static constexpr bool VALUE = false;
};
@@ -139,6 +148,9 @@ template <typename T> struct IsTernaryInput<TernaryInput<T>> {
template <typename T> struct MakeScalarInput : cpp::type_identity<T> {};
template <typename T>
struct MakeScalarInput<BinaryInput<T>> : cpp::type_identity<T> {};
template <typename T>
struct MakeScalarInput<TernaryInput<T>> : cpp::type_identity<T> {};
@@ -159,10 +171,11 @@ bool compare_binary_operation_two_outputs(Operation op,
double ulp_tolerance,
RoundingMode rounding);
template <typename T>
template <typename InputType, typename OutputType>
bool compare_binary_operation_one_output(Operation op,
const BinaryInput<T> &input,
T libc_output, double ulp_tolerance,
const BinaryInput<InputType> &input,
OutputType libc_output,
double ulp_tolerance,
RoundingMode rounding);
template <typename InputType, typename OutputType>
@@ -187,12 +200,10 @@ void explain_binary_operation_two_outputs_error(
const BinaryOutput<T> &match_value, double ulp_tolerance,
RoundingMode rounding);
template <typename T>
void explain_binary_operation_one_output_error(Operation op,
const BinaryInput<T> &input,
T match_value,
double ulp_tolerance,
RoundingMode rounding);
template <typename InputType, typename OutputType>
void explain_binary_operation_one_output_error(
Operation op, const BinaryInput<InputType> &input, OutputType match_value,
double ulp_tolerance, RoundingMode rounding);
template <typename InputType, typename OutputType>
void explain_ternary_operation_one_output_error(
@@ -235,7 +246,8 @@ private:
rounding);
}
template <typename T> bool match(const BinaryInput<T> &in, T out) {
template <typename T, typename U>
bool match(const BinaryInput<T> &in, U out) {
return compare_binary_operation_one_output(op, in, out, ulp_tolerance,
rounding);
}
@@ -268,7 +280,8 @@ private:
rounding);
}
template <typename T> void explain_error(const BinaryInput<T> &in, T out) {
template <typename T, typename U>
void explain_error(const BinaryInput<T> &in, U out) {
explain_binary_operation_one_output_error(op, in, out, ulp_tolerance,
rounding);
}
@@ -290,6 +303,10 @@ constexpr bool is_valid_operation() {
(op == Operation::Sqrt && cpp::is_floating_point_v<InputType> &&
cpp::is_floating_point_v<OutputType> &&
sizeof(OutputType) <= sizeof(InputType)) ||
(op == Operation::Div && internal::IsBinaryInput<InputType>::VALUE &&
cpp::is_floating_point_v<
typename internal::MakeScalarInput<InputType>::type> &&
cpp::is_floating_point_v<OutputType>) ||
(op == Operation::Fma && internal::IsTernaryInput<InputType>::VALUE &&
cpp::is_floating_point_v<
typename internal::MakeScalarInput<InputType>::type> &&