[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

27

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.

41

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).

61

+1 for this arrangement.

63

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.

68

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

27

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

18

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
+  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
+  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
+  SUITE
+    libc_math_unittests
+  SRCS
+    fminl_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.fminl
+    libc.utils.FPUtil.fputil
+)
 No newline at end of file

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/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<double>;
+
+double nan = static_cast<double>(FPBits::buildNaN(1));
+double inf = static_cast<double>(FPBits::inf());
+double negInf = static_cast<double>(FPBits::negInf());
+
+TEST(FminTest, NaNArg) {
+  EXPECT_EQ(inf, __llvm_libc::fmin(nan, inf));
+  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, nan));
+  EXPECT_EQ(0.0, __llvm_libc::fmin(nan, 0.0));
+  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, nan));
+  EXPECT_EQ(-1.2345, __llvm_libc::fmin(nan, -1.2345));
+  EXPECT_EQ(1.2345, __llvm_libc::fmin(1.2345, nan));
+  EXPECT_NE(isnan(__llvm_libc::fmin(nan, nan)), 0);
+}
+
+TEST(FminTest, InfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, inf));
+  EXPECT_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
+  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
+  EXPECT_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
+  EXPECT_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
+}
+
+TEST(FminTest, NegInfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fmin(inf, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
+  EXPECT_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
+  EXPECT_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
+}
+
+TEST(FminTest, BothZero) {
+  EXPECT_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
+  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
+  EXPECT_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
+  EXPECT_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
+}
+
+TEST(FminTest, 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) {
+    double x = FPBits(v), y = FPBits(w);
+    if (isnan(x) || isinf(x))
+      continue;
+    if (isnan(y) || isinf(y))
+      continue;
+    if ((x == 0) && (y == 0))
+      continue;
+
+    if (x < y) {
+      ASSERT_EQ(x, __llvm_libc::fmin(x, y));
+    } else {
+      ASSERT_EQ(y, __llvm_libc::fmin(x, y));
+    }
+  }
+}

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/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+float nan = static_cast<float>(FPBits::buildNaN(1));
+float inf = static_cast<float>(FPBits::inf());
+float negInf = static_cast<float>(FPBits::negInf());
+
+TEST(FminfTest, NaNArg) {
+  EXPECT_EQ(inf, __llvm_libc::fminf(nan, inf));
+  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, nan));
+  EXPECT_EQ(0.0f, __llvm_libc::fminf(nan, 0.0f));
+  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, nan));
+  EXPECT_EQ(-1.2345f, __llvm_libc::fminf(nan, -1.2345f));
+  EXPECT_EQ(1.2345f, __llvm_libc::fminf(1.2345f, nan));
+  EXPECT_NE(isnan(__llvm_libc::fminf(nan, nan)), 0);
+}
+
+TEST(FminfTest, InfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, inf));
+  EXPECT_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
+  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
+  EXPECT_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
+  EXPECT_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
+}
+
+TEST(FminfTest, NegInfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fminf(inf, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
+  EXPECT_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
+  EXPECT_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
+}
+
+TEST(FminfTest, BothZero) {
+  EXPECT_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
+  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
+  EXPECT_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
+  EXPECT_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
+}
+
+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))
+      continue;
+    if (isnan(y) || isinf(y))
+      continue;
+    if ((x == 0) && (y == 0))
+      continue;
+
+    if (x < y) {
+      ASSERT_EQ(x, __llvm_libc::fminf(x, y));
+    } else {
+      ASSERT_EQ(y, __llvm_libc::fminf(x, y));
+    }
+  }
+}

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/UnitTest/Test.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<long double>;
+
+long double nan = static_cast<long double>(FPBits::buildNaN(1));
+long double inf = static_cast<long double>(FPBits::inf());
+long double negInf = static_cast<long double>(FPBits::negInf());
+
+TEST(FminlTest, NaNArg) {
+  EXPECT_EQ(inf, __llvm_libc::fminl(nan, inf));
+  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, nan));
+  EXPECT_EQ(0.0L, __llvm_libc::fminl(nan, 0.0L));
+  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, nan));
+  EXPECT_EQ(-1.2345L, __llvm_libc::fminl(nan, -1.2345L));
+  EXPECT_EQ(1.2345L, __llvm_libc::fminl(1.2345L, nan));
+  EXPECT_NE(isnan(__llvm_libc::fminl(nan, nan)), 0);
+}
+
+TEST(FminlTest, InfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, inf));
+  EXPECT_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
+  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
+  EXPECT_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
+  EXPECT_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
+}
+
+TEST(FminlTest, NegInfArg) {
+  EXPECT_EQ(negInf, __llvm_libc::fminl(inf, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
+  EXPECT_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
+  EXPECT_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
+  EXPECT_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
+}
+
+TEST(FminlTest, BothZero) {
+  EXPECT_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
+  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
+  EXPECT_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
+  EXPECT_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
+}
+
+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))
+      continue;
+    if (isnan(y) || isinf(y))
+      continue;
+    if ((x == 0) && (y == 0))
+      continue;
+
+    if (x < y) {
+      ASSERT_EQ(x, __llvm_libc::fminl(x, y));
+    } else {
+      ASSERT_EQ(y, __llvm_libc::fminl(x, y));
+    }
+  }
+}

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
 )