[libc] Add implementations of fmin, fminf and fminl.

[lntue]

Fix clang-format

[sivachandra]

There are a few inline comments, but a few additional items:

1. This patch should also add cmake targets.
2. Why not also add fminl?

libc/test/src/math/fminf_test.cpp

13

We want to get rid of BitPatterns.h, FloatOperations.h and FloatProperites.h. Look at this to see how we can do it: https://github.com/llvm/llvm-project/blob/master/libc/test/src/math/ceill_test.cpp

Same for fmin_test.cpp as well.

51

Can we also add tests for non-special numbers?

libc/utils/FPUtil/ComparisonFunctions.h

1 ↗

(On Diff #275074)

On cppreference.com, fmin et al are listed under Basic operations. So, lets put their implementations in BasicOperations.h.

30 ↗

(On Diff #275074)

After the NaN checks, can we just do:

return x > y ? y : x;

32 ↗

(On Diff #275074)

This might become irrelevant if we can do as I suggested above. But, absBits(..) returns an integer. So, the integers are being compared here and not the underlying floating point numbers.

[lntue]

Add implementations of fmin, fminf, and fminl

[lntue]

Fix clang-format

[sivachandra]

The actual implementation LGTM. My comments are all for the test infrastructure. I have left comments only in fminl_test.cpp, but most of them are relevant for other tests as well. One of them is about using MPFR for testing fmin and friends. While what you have added to MPFRUtil will be required for functions like hypot, fma etc., it seems like it is an overkill for fmin. That said, feel free to convince me otherwise.

libc/test/src/math/fminl_test.cpp

26

Wouldn't casting to unsigned long long lead to truncation? If you actually feel strongly about this setup, I would suggest adding an __uint128 overload to EXPECT_EQ and friends.

40

This makes the code concise, but I am finding it really hard to read. Instead of having just one SpecialNumbers test class. What do you think of having three test classes like NaNArg, InfArg, BothZero. The NaNArg class tests with at least one NaN against a variety of numbers. The InfArg test would be similar. The BothZero test would test with (+0, +0), (+0, -0), (-0, +0), (-0, -0).

60

+1 for this arrangement.

62

Continuing on x == 0 skips comparisons for the kind fmin(0, <non-zero, non-inf. non-nan>). May be skip only if x == 0 && y == 0.

67

Do we really need MPFR here? Considering all special numbers (including zero) are tested separately, wouldn't it be sufficient to test this way:

if (x < y)
  ASSERT_FP_EQ(fmin(x, y), x);
else
  ASSERT_FP_EQ(fmix(x, y), y);

[lntue]

Add implementations of fmin, fminf, and fminl. Update Test to accept floating point types and __uint128_t.

[lntue]

libc/test/src/math/fminl_test.cpp

26

EXPECT_EQ and friends are now updated to accept __uint128 and floating point types.

[lntue]

Refactor utohexstr and overloads of raw_stream.operator<<

[sivachandra]

Still, overall LGTM. I have some inline comments for further chiseling. Also:

1. Can you split the UnitTest changes into a separate patch?
2. The variable naming style in Test.h and Test.cpp is old style like VarName. To keep the files uniform, please follow the existing style.

libc/utils/UnitTest/CMakeLists.txt

11 ↗

(On Diff #278027)

I would prefer not to need this, especially for tests.

libc/utils/UnitTest/Test.cpp

111 ↗

(On Diff #278027)

Isn't this always true? For, ValType is integral or floating point type anyway?

124 ↗

(On Diff #278027)

Instead of printing hex values conditioned on printHex (which I think is always true), WDYT of this when streaming out LHS and RHS values:

<< "     Which is: " << describeValue(LHS) << '\n';

The function describeValue is a template function which does this:

1. For integral types less than or of 64 bits, describeValue just returns the value as string.
2. For 128 bit integers, it returns a string of hex bits.
3. For floating point values, it returns a string like this: Sign: <1|0>, Exponent bits: <hex bits>, Manstissa Bits: <hex bits>

libc/utils/UnitTest/Test.h

82 ↗

(On Diff #278027)

Instead of checking for __uint128_t, you should extend IsIntegral trait to include __uint128_t.

[lntue]

Add implementations of fmin, fminf, and fminl. Testing infrastructure update is splitted to https://reviews.llvm.org/D83931.

[lntue]

libc/utils/UnitTest/Test.cpp

111 ↗

(On Diff #278027)

There is also StringRef type being instantiated.

124 ↗

(On Diff #278027)

There are also StringRef type being instantiated. I refactor this part and use template function describeValue to avoid constexpr in https://reviews.llvm.org/D83931

[sivachandra]

The tests look so much more readable now. Thanks for patiently working through the comments.
Just a note for future: We should setup differential fuzzers for math functions comparing LLVM libc results with results from system libc like glibc. And may be also a doc listing how we differ from glibc and the justification.

I have accepted this revision, but I guess you need to wait for the other patch to land before you can submit this. Also, I left couple nits inline. Please fix them if relevant.

libc/src/math/fminf.cpp

19

Newline?

libc/test/src/math/fmin_test.cpp

19

Here, and in the other test files, I don't think you need the static_cast. We have implicit conversion operators for FPBits.

[sivachandra]

I have updated the patch description. Please use the same when you submit via git.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.floor
     libc.src.math.floorf
     libc.src.math.floorl
+    libc.src.math.fmin
+    libc.src.math.fminf
+    libc.src.math.fminl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff

libc/config/linux/api.td

def MathAPI : PublicAPI<"math.h"> {
    "ceill",
    "cosf",
    "fabs",
    "fabsf",
    "fabsl",
    "floor",
    "floorf",
    "floorl",
+   "fmin",
+   "fminf",
+   "fminl",
    "frexp",
    "frexpf",
    "frexpl",
    "logb",
    "logbf",
    "logbl",
    "modf",
    "modff",

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.fabsl
     libc.src.math.floor
     libc.src.math.floorf
     libc.src.math.floorl
+    libc.src.math.fmin
+    libc.src.math.fminf
+    libc.src.math.fminl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"fabs", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"fabsf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"fabsl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"floor", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"floorf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"floorl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
+          FunctionSpec<"fmin", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
+          FunctionSpec<"fminf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
+          FunctionSpec<"fminl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
+
           FunctionSpec<"frexp", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"frexpf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<IntPtr>]>,
           FunctionSpec<"frexpl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<IntPtr>]>,
 
           FunctionSpec<"logb", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"logbf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"logbl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 

libc/src/math/CMakeLists.txt

SRCS
     modfl.cpp
   HDRS
     modfl.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
+
+add_entrypoint_object(
+  fmin
+  SRCS
+    fmin.cpp
+  HDRS
+    fmin.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  fminf
+  SRCS
+    fminf.cpp
+  HDRS
+    fminf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  fminl
+  SRCS
+    fminl.cpp
+  HDRS
+    fminl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)

libc/src/math/fmin.h

+//===-- Implementation header for fmin --------------------------*- 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_FMIN_H
+#define LLVM_LIBC_SRC_MATH_FMIN_H
+
+namespace __llvm_libc {
+
+double fmin(double x, double y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_FMIN_H

libc/src/math/fmin.cpp

+//===-- Implementation of fmin 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/__support/common.h"
+#include "utils/FPUtil/BasicOperations.h"
+
+namespace __llvm_libc {
+
+double LLVM_LIBC_ENTRYPOINT(fmin)(double x, double y) {
+  return fputil::fmin(x, y);
+}
+
+} // namespace __llvm_libc

libc/src/math/fminf.h

+//===-- Implementation header for fminf -------------------------*- 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_FMINF_H
+#define LLVM_LIBC_SRC_MATH_FMINF_H
+
+namespace __llvm_libc {
+
+float fminf(float x, float y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_FMINF_H

libc/src/math/fminf.cpp

+//===-- Implementation of fminf 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/__support/common.h"
+#include "utils/FPUtil/BasicOperations.h"
+
+namespace __llvm_libc {
+
+float LLVM_LIBC_ENTRYPOINT(fminf)(float x, float y) {
+  return fputil::fmin(x, y);
+}
+
+} // namespace __llvm_libc
 No newline at end of file

libc/src/math/fminl.h

+//===-- Implementation header for fminl -------------------------*- 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_FMINL_H
+#define LLVM_LIBC_SRC_MATH_FMINL_H
+
+namespace __llvm_libc {
+
+long double fminl(long double x, long double y);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_FMINL_H

libc/src/math/fminl.cpp

+//===-- Implementation of fminl 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/__support/common.h"
+#include "utils/FPUtil/BasicOperations.h"
+
+namespace __llvm_libc {
+
+long double LLVM_LIBC_ENTRYPOINT(fminl)(long double x, long double y) {
+  return fputil::fmin(x, y);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SUITE
     libc_math_unittests
   SRCS
     modfl_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.modfl
     libc.utils.FPUtil.fputil
 )
+
+add_math_unittest(
+  fminf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fminf_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fminf
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
+  fmin_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fmin_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fmin
+    libc.utils.FPUtil.fputil
+)
+
+add_math_unittest(
+  fminl_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    fminl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fminl
+    libc.utils.FPUtil.fputil
+)

libc/test/src/math/fmin_test.cpp

+//===-- Unittests for fmin -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#include <vector>
+
+#include "include/math.h"
+#include "src/math/fmin.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<double>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+                                           0};
+
+#define EXPECT_FP_EQ(LHS, RHS)                                                 \
+  EXPECT_EQ(FPBits(LHS).bitsAsUInt(), FPBits(RHS).bitsAsUInt())
+
+TEST(FminTest, SpecialNumbers) {
+  std::vector<double> orderedValues;
+
+  orderedValues.push_back(double(FPBits::negInf()));
+  orderedValues.push_back(-1.2345);
+  orderedValues.push_back(double(FPBits::negZero()));
+  orderedValues.push_back(0.0);
+  orderedValues.push_back(1.2345);
+  orderedValues.push_back(double(FPBits::inf()));
+
+  for (size_t i = 0; i < orderedValues.size(); ++i) {
+    for (size_t j = 0; j < orderedValues.size(); ++j) {
+      EXPECT_FP_EQ(orderedValues[(i < j ? i : j)],
+                   __llvm_libc::fmin(orderedValues[i], orderedValues[j]));
+    }
+  }
+
+  double nan = FPBits::buildNaN(1);
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fmin(nan, orderedValues[0]));
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fmin(orderedValues[0], nan));
+
+  EXPECT_NE(isnan(__llvm_libc::fmin(nan, nan)), 0);
+}
+
+TEST(FminTest, InDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; ++i, v += step, w -= step) {
+    double x = FPBits(v), y = FPBits(w);
+    if (isnan(x) || isinf(x) || x == 0)
+      continue;
+    if (isnan(y) || isinf(y) || y == 0)
+      continue;
+
+    ASSERT_MPFR_MATCH_BINOP(mpfr::BinaryOperation::Fmin, x, y,
+                            __llvm_libc::fmin(x, y),
+                            tolerance);
+  }
+}

libc/test/src/math/fminf_test.cpp

+//===-- Unittests for fminf ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#include <vector>
+
+#include "include/math.h"
+#include "src/math/fminf.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
+                                           0};
+
+#define EXPECT_FP_EQ(LHS, RHS)                                                 \
+  EXPECT_EQ(FPBits(LHS).bitsAsUInt(), FPBits(RHS).bitsAsUInt())
+
+TEST(FminfTest, SpecialNumbers) {
+  std::vector<float> orderedValues;
+
+  orderedValues.push_back(float(FPBits::negInf()));
+  orderedValues.push_back(-1.2345f);
+  orderedValues.push_back(float(FPBits::negZero()));
+  orderedValues.push_back(0.0f);
+  orderedValues.push_back(1.2345f);
+  orderedValues.push_back(float(FPBits::inf()));
+
+  for (size_t i = 0; i < orderedValues.size(); ++i) {
+    for (size_t j = 0; j < orderedValues.size(); ++j) {
+      EXPECT_FP_EQ(orderedValues[(i < j ? i : j)],
+                   __llvm_libc::fminf(orderedValues[i], orderedValues[j]));
+    }
+  }
+
+  float nan = static_cast<float>(FPBits::buildNaN(1));
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fminf(nan, orderedValues[0]));
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fminf(orderedValues[0], nan));
+
+  EXPECT_NE(isnan(__llvm_libc::fminf(nan, nan)), 0);
+}
+
+TEST(FminfTest, InFloatRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; ++i, v += step, w -= step) {
+    float x = FPBits(v), y = FPBits(w);
+    if (isnan(x) || isinf(x) || x == 0)
+      continue;
+    if (isnan(y) || isinf(y) || y == 0)
+      continue;
+
+    ASSERT_MPFR_MATCH_BINOP(mpfr::BinaryOperation::Fmin, x, y,
+                            __llvm_libc::fminf(x, y),
+                            tolerance);
+  }
+}

libc/test/src/math/fminl_test.cpp

+//===-- Unittests for fmin -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#include <vector>
+
+#include "include/math.h"
+#include "src/math/fminl.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+// Zero tolerance; As in, exact match with MPFR result.
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+                                           0};
+
+#define GET_BITS(LD_VALUE)                                                     \
+  static_cast<unsigned long long>(FPBits(LD_VALUE).bitsAsUInt())
+
+#define EXPECT_FP_EQ(LHS, RHS) EXPECT_EQ(GET_BITS(LHS), GET_BITS(RHS))
+
+TEST(FminlTest, SpecialNumbers) {
+  std::vector<long double> orderedValues;
+
+  orderedValues.push_back(static_cast<long double>(FPBits::negInf()));
+  orderedValues.push_back(-1.2345l);
+  orderedValues.push_back(static_cast<long double>(FPBits::negZero()));
+  orderedValues.push_back(0.0l);
+  orderedValues.push_back(1.2345l);
+  orderedValues.push_back(static_cast<long double>(FPBits::inf()));
+
+  for (size_t i = 0; i < orderedValues.size(); ++i) {
+    for (size_t j = 0; j < orderedValues.size(); ++j) {
+      EXPECT_FP_EQ(orderedValues[(i < j ? i : j)],
+                   __llvm_libc::fminl(orderedValues[i], orderedValues[j]));
+    }
+  }
+
+  long double nan = static_cast<long double>(FPBits::buildNaN(1));
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fminl(nan, orderedValues[0]));
+
+  EXPECT_FP_EQ(orderedValues[0], __llvm_libc::fminl(orderedValues[0], nan));
+
+  EXPECT_NE(isnan(__llvm_libc::fminl(nan, nan)), 0);
+}
+
+TEST(FminlTest, InLongDoubleRange) {
+  using UIntType = FPBits::UIntType;
+  constexpr UIntType count = 10000000;
+  constexpr UIntType step = UIntType(-1) / count;
+  for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count; ++i, v += step, w -= step) {
+    long double x = FPBits(v), y = FPBits(w);
+    if (isnan(x) || isinf(x) || x == 0)
+      continue;
+    if (isnan(y) || isinf(y) || y == 0)
+      continue;
+
+    ASSERT_MPFR_MATCH_BINOP(mpfr::BinaryOperation::Fmin, x, y,
+                            __llvm_libc::fminl(x, y),
+                            tolerance);
+  }
+}

libc/utils/FPUtil/BasicOperations.h

 template <typename T,
           cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
 static inline T abs(T x) {
   FPBits<T> bits(x);
   bits.sign = 0;
   return T(bits);
 }
 
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T fmin(T x, T y) {
+  FPBits<T> bitx(x), bity(y);
+
+  if (bitx.isNaN()) {
+    return y;
+  } else if (bity.isNaN()) {
+    return x;
+  } else if (bitx.sign != bity.sign) {
+    // To make sure that fmin(+0, -0) == -0 == fmin(-0, +0), whenever x and
+    // y has different signs and both are not NaNs, we return the number
+    // with negative sign.
+    return (bitx.sign ? x : y);
+  } else {
+    return (x < y ? x : y);
+  }
+}
+
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_BASIC_OPERATIONS_H

libc/utils/FPUtil/CMakeLists.txt

 if(${LIBC_TARGET_MACHINE} MATCHES "^x86.*")
   set(LONG_DOUBLE_HDR LongDoubleBitsX86.h)
 else()
   set(LONG_DOUBLE_HDR)
 endif()
 
 add_header_library(
   fputil
   HDRS
     ${LONG_DOUBLE_HDR}
     BitPatterns.h
     FloatOperations.h
     FloatProperties.h
     FPBits.h
+    BasicOperations.h
     ManipulationFunctions.h
   DEPENDS
     libc.utils.CPP.standalone_cpp
 )

libc/utils/MPFRWrapper/MPFRUtils.h

 //===-- MPFRUtils.h ---------------------------------------------*- 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_UTILS_TESTUTILS_MPFRUTILS_H
 #define LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H
 
 #include "utils/CPP/TypeTraits.h"
 #include "utils/UnitTest/Test.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 namespace mpfr {
 
enum class Operation : int {
   Exp,
   Exp2,
   Floor,
   Round,
   Sin,
   Trunc
 };
 
+enum class BinaryOperation : int {
+  Fmin
+};
+
 namespace internal {
 
 template <typename T>
 bool compare(Operation op, T input, T libcOutput, const Tolerance &t);
 
+template <typename T>
+bool compare(BinaryOperation op, T input1, T input2, T libcOutput, const Tolerance &t);
+
 template <typename T> class MPFRMatcher : public testing::Matcher<T> {
   static_assert(__llvm_libc::cpp::IsFloatingPointType<T>::Value,
                 "MPFRMatcher can only be used with floating point values.");
 
   Operation operation;
-  T input;
+  BinaryOperation binaryOperation;
+  T input, secondInput;
   Tolerance tolerance;
   T matchValue;
+  int numberOfInputs;
 
 public:
   MPFRMatcher(Operation op, T testInput, Tolerance &t)
-      : operation(op), input(testInput), tolerance(t) {}
+      : operation(op), input(testInput), tolerance(t), numberOfInputs(1) {}
+
+  MPFRMatcher(BinaryOperation op, T testInput1, T testInput2, Tolerance &t)
+      : binaryOperation(op), input(testInput1), secondInput(testInput2), tolerance(t), numberOfInputs(2) {}
 
   bool match(T libcResult) {
     matchValue = libcResult;
+    if (numberOfInputs == 1) {
       return internal::compare(operation, input, libcResult, tolerance);
+    } else {
+      // numberOfInputs == 2
+      return internal::compare(binaryOperation, input, secondInput, libcResult, tolerance);
+    }
   }
 
   void explainError(testutils::StreamWrapper &OS) override;
 };
 
 } // namespace internal
 
 template <typename T>
 __attribute__((no_sanitize("address")))
 internal::MPFRMatcher<T> getMPFRMatcher(Operation op, T input, Tolerance t) {
   static_assert(
       __llvm_libc::cpp::IsFloatingPointType<T>::Value,
       "getMPFRMatcher can only be used to match floating point results.");
   return internal::MPFRMatcher<T>(op, input, t);
 }
 
+template <typename T>
+__attribute__((no_sanitize("address")))
+internal::MPFRMatcher<T> getMPFRMatcher(BinaryOperation op, T input1, T input2, Tolerance t) {
+  static_assert(
+      __llvm_libc::cpp::IsFloatingPointType<T>::Value,
+      "getMPFRMatcher can only be used to match floating point results.");
+  return internal::MPFRMatcher<T>(op, input1, input2, t);
+}
+
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc
 
 #define EXPECT_MPFR_MATCH(op, input, matchValue, tolerance)                    \
   EXPECT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher(          \
                               op, input, tolerance))
 
 #define ASSERT_MPFR_MATCH(op, input, matchValue, tolerance)                    \
   ASSERT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher(          \
                               op, input, tolerance))
 
+#define EXPECT_MPFR_MATCH_BINOP(op, input1, input2, matchValue, tolerance)     \
+  EXPECT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher(          \
+                              op, input1, input2, tolerance))
+
+#define ASSERT_MPFR_MATCH_BINOP(op, input1, input2, matchValue, tolerance)     \
+  ASSERT_THAT(matchValue, __llvm_libc::testing::mpfr::getMPFRMatcher(          \
+                              op, input1, input2, tolerance))
+
 #endif // LLVM_LIBC_UTILS_TESTUTILS_MPFRUTILS_H

libc/utils/MPFRWrapper/MPFRUtils.cpp

case Operation::Sin:
       mpfr_sin(value, mpfrInput.value, MPFR_RNDN);
       break;
     case Operation::Trunc:
       mpfr_trunc(value, mpfrInput.value);
       break;
     }
   }
 
+  template <typename XType,
+            cpp::EnableIfType<cpp::IsFloatingPointType<XType>::Value, int> = 0>
+  MPFRNumber(BinaryOperation op, XType rawValue1, XType rawValue2) {
+    mpfr_init2(value, mpfrPrecision);
+    MPFRNumber mpfrInput1(rawValue1), mpfrInput2(rawValue2);
+    switch (op) {
+    case BinaryOperation::Fmin:
+      mpfr_min(value, mpfrInput1.value, mpfrInput2.value, MPFR_RNDN);
+      break;
+    }
+  }
+
   MPFRNumber(const MPFRNumber &other) {
     mpfr_set(value, other.value, MPFR_RNDN);
   }
 
   ~MPFRNumber() { mpfr_clear(value); }
 
   // Returns true if |other| is within the |tolerance| value of this
   // number.
public:
   double asDouble() const { return mpfr_get_d(value, MPFR_RNDN); }
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
 };
 
 namespace internal {
 
 template <typename T>
 void MPFRMatcher<T>::explainError(testutils::StreamWrapper &OS) {
-  MPFRNumber mpfrResult(operation, input);
+  MPFRNumber mpfrResult = (numberOfInputs == 1 ? MPFRNumber(operation, input)
+                                               : MPFRNumber(binaryOperation, input, secondInput));
   MPFRNumber mpfrInput(input);
   MPFRNumber mpfrMatchValue(matchValue);
   MPFRNumber mpfrToleranceValue(matchValue, tolerance);
   FPBits<T> inputBits(input);
   FPBits<T> matchBits(matchValue);
   // TODO: Call to llvm::utohexstr implicitly converts __uint128_t values to
   // uint64_t values. This can be fixed using a custom wrapper for
   // llvm::utohexstr to handle __uint128_t values correctly.
   OS << "Match value not within tolerance value of MPFR result:\n"
      << "  Input decimal: " << mpfrInput.str() << '\n'
-     << "     Input bits: 0x" << llvm::utohexstr(inputBits.bitsAsUInt()) << '\n'
-     << "  Match decimal: " << mpfrMatchValue.str() << '\n'
+     << "     Input bits: 0x" << llvm::utohexstr(inputBits.bitsAsUInt()) << '\n';
+  if (numberOfInputs == 2) {
+    MPFRNumber mpfrSecondInput(secondInput);
+    FPBits<T> secondInputBits(secondInput);
+    OS << "  Second Input decimal: " << mpfrSecondInput.str() << '\n'
+       << "     Second input bits: 0x" << llvm::utohexstr(secondInputBits.bitsAsUInt()) << '\n';
+  }
+  OS << "  Match decimal: " << mpfrMatchValue.str() << '\n'
      << "     Match bits: 0x" << llvm::utohexstr(matchBits.bitsAsUInt()) << '\n'
      << "    MPFR result: " << mpfrResult.str() << '\n'
      << "Tolerance value: " << mpfrToleranceValue.str() << '\n';
 }
 
 template void MPFRMatcher<float>::explainError(testutils::StreamWrapper &);
 template void MPFRMatcher<double>::explainError(testutils::StreamWrapper &);
 template void
 MPFRMatcher<long double>::explainError(testutils::StreamWrapper &);
 
 template <typename T>
 bool compare(Operation op, T input, T libcResult, const Tolerance &t) {
   MPFRNumber mpfrResult(op, input);
   MPFRNumber mpfrLibcResult(libcResult);
   MPFRNumber mpfrToleranceValue(libcResult, t);
 
   return mpfrResult.isEqual(mpfrLibcResult, mpfrToleranceValue);
 };
 
 template bool compare<float>(Operation, float, float, const Tolerance &);
 template bool compare<double>(Operation, double, double, const Tolerance &);
 template bool compare<long double>(Operation, long double, long double,
                                    const Tolerance &);
 
+template <typename T>
+bool compare(BinaryOperation binop, T input1, T input2, T libcResult, const Tolerance &t) {
+  MPFRNumber mpfrResult(binop, input1, input2);
+  MPFRNumber mpfrLibcResult(libcResult);
+  MPFRNumber mpfrToleranceValue(libcResult, t);
+
+  return mpfrResult.isEqual(mpfrLibcResult, mpfrToleranceValue);
+};
+
+template bool compare<float>(BinaryOperation, float, float, float, const Tolerance &);
+template bool compare<double>(BinaryOperation, double, double, double, const Tolerance &);
+template bool compare<long double>(BinaryOperation, long double, long double, long double,
+                                   const Tolerance &);
+
 } // namespace internal
 
 } // namespace mpfr
 } // namespace testing
 } // namespace __llvm_libc