[libc][math][c23] Add f16subf C23 math function

libc/config/linux/aarch64/entrypoints.txt

@@ -514,6 +514,7 @@ if(LIBC_TYPES_HAS_FLOAT16)
     libc.src.math.f16fmaf
     libc.src.math.f16sqrt
     libc.src.math.f16sqrtf
+    libc.src.math.f16subf
     libc.src.math.fabsf16
     libc.src.math.fdimf16
     libc.src.math.floorf16

libc/config/linux/x86_64/entrypoints.txt

@@ -548,6 +548,7 @@ if(LIBC_TYPES_HAS_FLOAT16)
     libc.src.math.f16sqrt
     libc.src.math.f16sqrtf
     libc.src.math.f16sqrtl
+    libc.src.math.f16subf
     libc.src.math.fabsf16
     libc.src.math.fdimf16
     libc.src.math.floorf16

libc/docs/math/index.rst

@@ -130,6 +130,8 @@ Basic Operations
 +------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
 | f16fma           | |check|          | |check|         | |check|                | N/A                  | |check|                | 7.12.14.5              | F.10.11                    |
 +------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
+| f16sub           | |check|          |                 |                        | N/A                  |                        | 7.12.14.2              | F.10.11                    |
++------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
 | fabs             | |check|          | |check|         | |check|                | |check|              | |check|                | 7.12.7.3               | F.10.4.3                   |
 +------------------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+
 | fadd             | N/A              |                 |                        | N/A                  |                        | 7.12.14.1              | F.10.11                    |

libc/spec/stdc.td

@@ -731,6 +731,8 @@ def StdC : StandardSpec<"stdc"> {
 
           GuardedFunctionSpec<"f16addf", RetValSpec<Float16Type>, [ArgSpec<FloatType>, ArgSpec<FloatType>], "LIBC_TYPES_HAS_FLOAT16">,
 
+          GuardedFunctionSpec<"f16subf", RetValSpec<Float16Type>, [ArgSpec<FloatType>, ArgSpec<FloatType>], "LIBC_TYPES_HAS_FLOAT16">,
+
           GuardedFunctionSpec<"f16divf128", RetValSpec<Float16Type>, [ArgSpec<Float128Type>, ArgSpec<Float128Type>], "LIBC_TYPES_HAS_FLOAT16_AND_FLOAT128">,
 
           GuardedFunctionSpec<"f16sqrtf128", RetValSpec<Float16Type>, [ArgSpec<Float128Type>], "LIBC_TYPES_HAS_FLOAT16_AND_FLOAT128">,

libc/src/__support/FPUtil/generic/CMakeLists.txt

@@ -50,9 +50,9 @@ add_header_library(
 )
 
 add_header_library(
-  add
+  add_sub
   HDRS
-    add.h
+    add_sub.h
   DEPENDS
     libc.hdr.errno_macros
     libc.hdr.fenv_macros

libc/src/__support/FPUtil/generic/add.h → libc/src/__support/FPUtil/generic/add_sub.h

@@ -1,13 +1,13 @@
-//===-- Addition of IEEE 754 floating-point numbers -------------*- C++ -*-===//
+//===-- Add and subtract 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_ADD_H
-#define LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_ADD_H
+#ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_ADD_SUB_H
+#define LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_ADD_SUB_H
 
 #include "hdr/errno_macros.h"
 #include "hdr/fenv_macros.h"
@@ -24,12 +24,12 @@
 
 namespace LIBC_NAMESPACE::fputil::generic {
 
-template <typename OutType, typename InType>
+template <bool IsSub, 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>
-add(InType x, InType y) {
+add_or_sub(InType x, InType y) {
   using OutFPBits = FPBits<OutType>;
   using OutStorageType = typename OutFPBits::StorageType;
   using InFPBits = FPBits<InType>;
@@ -45,6 +45,8 @@ add(InType x, InType y) {
   InFPBits x_bits(x);
   InFPBits y_bits(y);
 
+  bool is_effectively_add = (x_bits.sign() == y_bits.sign()) ^ IsSub;
+
   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()) {
@@ -72,7 +74,7 @@ add(InType x, InType y) {
 
     if (x_bits.is_inf()) {
       if (y_bits.is_inf()) {
-        if (x_bits.sign() != y_bits.sign()) {
+        if (!is_effectively_add) {
           raise_except_if_required(FE_INVALID);
           return OutFPBits::quiet_nan().get_val();
         }
@@ -106,7 +108,7 @@ add(InType x, InType y) {
   InType x_abs = x_bits.abs().get_val();
   InType y_abs = y_bits.abs().get_val();
 
-  if (x_abs == y_abs && x_bits.sign() != y_bits.sign()) {
+  if (x_abs == y_abs && !is_effectively_add) {
     switch (quick_get_round()) {
     case FE_DOWNWARD:
       return OutFPBits::zero(Sign::NEG).get_val();
@@ -117,12 +119,16 @@ add(InType x, InType y) {
 
   Sign result_sign = Sign::POS;
 
-  if (x_abs > y_abs)
+  if (x_abs > y_abs) {
     result_sign = x_bits.sign();
-  else if (x_abs < y_abs)
-    result_sign = y_bits.sign();
-  else if (x_bits.sign() == y_bits.sign())
+  } else if (x_abs < y_abs) {
+    if (is_effectively_add)
+      result_sign = y_bits.sign();
+    else if (y_bits.is_pos())
+      result_sign = Sign::NEG;
+  } else if (is_effectively_add) {
     result_sign = x_bits.sign();
+  }
 
   InFPBits max_bits(cpp::max(x_abs, y_abs));
   InFPBits min_bits(cpp::min(x_abs, y_abs));
@@ -131,7 +137,8 @@ add(InType x, InType y) {
 
   if (max_bits.is_subnormal()) {
     // min_bits must be subnormal too.
-    if (max_bits.sign() == min_bits.sign())
+
+    if (is_effectively_add)
       result_mant = max_bits.get_mantissa() + min_bits.get_mantissa();
     else
       result_mant = max_bits.get_mantissa() - min_bits.get_mantissa();
@@ -155,7 +162,7 @@ add(InType x, InType y) {
     else
       aligned_min_mant_sticky = true;
 
-    if (max_bits.sign() == min_bits.sign())
+    if (is_effectively_add)
       result_mant = max_mant + (aligned_min_mant | aligned_min_mant_sticky);
     else
       result_mant = max_mant - (aligned_min_mant | aligned_min_mant_sticky);
@@ -166,6 +173,24 @@ add(InType x, InType y) {
   return result.template as<OutType, /*ShouldSignalExceptions=*/true>();
 }
 
+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>
+add(InType x, InType y) {
+  return add_or_sub</*IsSub=*/false, OutType>(x, y);
+}
+
+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>
+sub(InType x, InType y) {
+  return add_or_sub</*IsSub=*/true, OutType>(x, y);
+}
+
 } // namespace LIBC_NAMESPACE::fputil::generic
 
-#endif // LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_ADD_H
+#endif // LLVM_LIBC_SRC___SUPPORT_FPUTIL_GENERIC_ADD_SUB_H

libc/src/math/CMakeLists.txt

@@ -116,6 +116,8 @@ add_math_entrypoint_object(f16sqrtf)
 add_math_entrypoint_object(f16sqrtl)
 add_math_entrypoint_object(f16sqrtf128)
 
+add_math_entrypoint_object(f16subf)
+
 add_math_entrypoint_object(fabs)
 add_math_entrypoint_object(fabsf)
 add_math_entrypoint_object(fabsl)

libc/src/math/f16subf.h

@@ -0,0 +1,20 @@
+//===-- Implementation header for f16subf -----------------------*- 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_F16SUBF_H
+#define LLVM_LIBC_SRC_MATH_F16SUBF_H
+
+#include "src/__support/macros/properties/types.h"
+
+namespace LIBC_NAMESPACE {
+
+float16 f16subf(float x, float y);
+
+} // namespace LIBC_NAMESPACE
+
+#endif // LLVM_LIBC_SRC_MATH_F16SUBF_H

libc/src/math/generic/CMakeLists.txt

@@ -3803,7 +3803,20 @@ add_entrypoint_object(
     ../f16addf.h
   DEPENDS
     libc.src.__support.macros.properties.types
-    libc.src.__support.FPUtil.generic.add
+    libc.src.__support.FPUtil.generic.add_sub
+  COMPILE_OPTIONS
+    -O3
+)
+
+add_entrypoint_object(
+  f16subf
+  SRCS
+    f16subf.cpp
+  HDRS
+    ../f16subf.h
+  DEPENDS
+    libc.src.__support.macros.properties.types
+    libc.src.__support.FPUtil.generic.add_sub
   COMPILE_OPTIONS
     -O3
 )

libc/src/math/generic/f16addf.cpp

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/math/f16addf.h"
-#include "src/__support/FPUtil/generic/add.h"
+#include "src/__support/FPUtil/generic/add_sub.h"
 #include "src/__support/common.h"
 
 namespace LIBC_NAMESPACE {

libc/src/math/generic/f16subf.cpp

@@ -0,0 +1,19 @@
+//===-- Implementation of f16subf 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/f16subf.h"
+#include "src/__support/FPUtil/generic/add_sub.h"
+#include "src/__support/common.h"
+
+namespace LIBC_NAMESPACE {
+
+LLVM_LIBC_FUNCTION(float16, f16subf, (float x, float y)) {
+  return fputil::generic::sub<float16>(x, y);
+}
+
+} // namespace LIBC_NAMESPACE

libc/test/src/math/CMakeLists.txt

@@ -2009,6 +2009,19 @@ add_fp_unittest(
     libc.src.math.f16addf
 )
 
+add_fp_unittest(
+  f16subf_test
+  NEED_MPFR
+  SUITE
+    libc-math-unittests
+  SRCS
+    f16subf_test.cpp
+  HDRS
+    SubTest.h
+  DEPENDS
+    libc.src.math.f16subf
+)
+
 add_fp_unittest(
   f16div_test
   NEED_MPFR

libc/test/src/math/SubTest.h

@@ -0,0 +1,73 @@
+//===-- Utility class to test different flavors of float sub ----*- 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_SUBTEST_H
+#define LLVM_LIBC_TEST_SRC_MATH_SUBTEST_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 SubTest : 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:
+  typedef OutType (*AddFunc)(InType, InType);
+
+  void test_subnormal_range(AddFunc func) {
+    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::Sub, input, func(x, y),
+                                     0.5);
+    }
+  }
+
+  void test_normal_range(AddFunc 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::Sub, input, func(x, y),
+                                     0.5);
+    }
+  }
+};
+
+#define LIST_SUB_TESTS(OutType, InType, func)                                  \
+  using LlvmLibcSubTest = SubTest<OutType, InType>;                            \
+  TEST_F(LlvmLibcSubTest, SubnormalRange) { test_subnormal_range(&func); }     \
+  TEST_F(LlvmLibcSubTest, NormalRange) { test_normal_range(&func); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_ADDTEST_H

libc/test/src/math/f16subf_test.cpp

@@ -0,0 +1,13 @@
+//===-- Unittests for f16subf ---------------------------------------------===//
+//
+// 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 "SubTest.h"
+
+#include "src/math/f16subf.h"
+
+LIST_SUB_TESTS(float16, float, LIBC_NAMESPACE::f16subf)

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

@@ -3658,6 +3658,20 @@ add_fp_unittest(
     libc.src.math.f16addf
 )
 
+add_fp_unittest(
+  f16subf_test
+  SUITE
+    libc-math-smoke-tests
+  SRCS
+    f16subf_test.cpp
+  HDRS
+    SubTest.h
+  DEPENDS
+    libc.hdr.fenv_macros
+    libc.src.__support.FPUtil.basic_operations
+    libc.src.math.f16subf
+)
+
 add_fp_unittest(
   f16div_test
   SUITE