[libc] Implement log1pf correctly rounded to all rounding modes.

[lntue]

Summary

Implement log1pf correctly rounded to all rounding modes relying on logf implementation for exponent > 2^(-8).

[zimmermann6]

I get several warnings when I compile this version:

In file included from /localdisk/zimmerma/llvm-project/libc/src/stdlib/strtold.cpp:11:
In file included from /localdisk/zimmerma/llvm-project/libc/src/__support/str_to_float.h:16:
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:115:42: warning: comparison of integers of different signs: 'int32_t' (aka 'int') and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
    if (roundToDigit < 0 || roundToDigit >= this->num_digits) {
                            ~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:121:26: warning: comparison of integers of different signs: 'int' and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
        roundToDigit + 1 == this->num_digits) {
        ~~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~

[zimmermann6]

apart the compiler warnings, all exhaustive tests comparing to MPFR do pass, for all four rounding modes. Good work!

[lntue]

In D118962#3296015, @zimmermann6 wrote:

I get several warnings when I compile this version:

In file included from /localdisk/zimmerma/llvm-project/libc/src/stdlib/strtold.cpp:11:
In file included from /localdisk/zimmerma/llvm-project/libc/src/__support/str_to_float.h:16:
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:115:42: warning: comparison of integers of different signs: 'int32_t' (aka 'int') and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
    if (roundToDigit < 0 || roundToDigit >= this->num_digits) {
                            ~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:121:26: warning: comparison of integers of different signs: 'int' and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
        roundToDigit + 1 == this->num_digits) {
        ~~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~

We are in the process of cleaning up the project to build with gcc. Thess warnings will be fixed soon.

[sivachandra]

In D118962#3296663, @lntue wrote:

In D118962#3296015, @zimmermann6 wrote:

I get several warnings when I compile this version:

In file included from /localdisk/zimmerma/llvm-project/libc/src/stdlib/strtold.cpp:11:
In file included from /localdisk/zimmerma/llvm-project/libc/src/__support/str_to_float.h:16:
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:115:42: warning: comparison of integers of different signs: 'int32_t' (aka 'int') and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
    if (roundToDigit < 0 || roundToDigit >= this->num_digits) {
                            ~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:121:26: warning: comparison of integers of different signs: 'int' and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
        roundToDigit + 1 == this->num_digits) {
        ~~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~

We are in the process of cleaning up the project to build with gcc. Thess warnings will be fixed soon.

Are these warnings really related to the GCC work?

[lntue]

In D118962#3301777, @sivachandra wrote:

In D118962#3296663, @lntue wrote:

In D118962#3296015, @zimmermann6 wrote:

I get several warnings when I compile this version:

In file included from /localdisk/zimmerma/llvm-project/libc/src/stdlib/strtold.cpp:11:
In file included from /localdisk/zimmerma/llvm-project/libc/src/__support/str_to_float.h:16:
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:115:42: warning: comparison of integers of different signs: 'int32_t' (aka 'int') and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
    if (roundToDigit < 0 || roundToDigit >= this->num_digits) {
                            ~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~
/localdisk/zimmerma/llvm-project/libc/src/__support/high_precision_decimal.h:121:26: warning: comparison of integers of different signs: 'int' and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
        roundToDigit + 1 == this->num_digits) {
        ~~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~

We are in the process of cleaning up the project to build with gcc. Thess warnings will be fixed soon.

Are these warnings really related to the GCC work?

These warnings are caused by https://reviews.llvm.org/D118791 and being fixed by https://reviews.llvm.org/D119156

[michaelrj]

overall LGTM with minor nit

libc/src/math/generic/log1pf.cpp

33

should this be in common_constants.cpp?

[lntue]

Move LOG_F table to common_constants.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.lrintl
     libc.src.math.lround
     libc.src.math.lroundf
     libc.src.math.lroundl
     libc.src.math.ldexp
     libc.src.math.ldexpf
     libc.src.math.ldexpl
     libc.src.math.log10f
+    libc.src.math.log1pf
     libc.src.math.log2f
     libc.src.math.logf
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.ldexpl
     libc.src.math.llrint
     libc.src.math.llrintf
     libc.src.math.llrintl
     libc.src.math.llround
     libc.src.math.llroundf
     libc.src.math.llroundl
     libc.src.math.log10f
+    libc.src.math.log1pf
     libc.src.math.log2f
     libc.src.math.logf
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.lrint
     libc.src.math.lrintf
     libc.src.math.lrintl

libc/config/windows/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.ilogbf
     libc.src.math.ilogbl
     libc.src.math.ldexp
     libc.src.math.ldexpf
     libc.src.math.ldexpl
     libc.src.math.llround
     libc.src.math.llroundf
     libc.src.math.llroundl
+    libc.src.math.log1pf
     libc.src.math.log2f
     libc.src.math.logf
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.lround
     libc.src.math.lroundf
     libc.src.math.lroundl

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"ilogbl", RetValSpec<IntType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"ldexp", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<IntType>]>,
           FunctionSpec<"ldexpf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<IntType>]>,
           FunctionSpec<"ldexpl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<IntType>]>,
 
           FunctionSpec<"log10f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
+          FunctionSpec<"log1pf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+
           FunctionSpec<"log2f", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"logf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
 
           FunctionSpec<"logb", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"logbf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"logbl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 

libc/src/math/CMakeLists.txt

 add_math_entrypoint_object(ilogbl)
 
 add_math_entrypoint_object(ldexp)
 add_math_entrypoint_object(ldexpf)
 add_math_entrypoint_object(ldexpl)
 
 add_math_entrypoint_object(log10f)
 
+add_math_entrypoint_object(log1pf)
+
 add_math_entrypoint_object(log2f)
 
 add_math_entrypoint_object(logf)
 
 add_math_entrypoint_object(logb)
 add_math_entrypoint_object(logbf)
 add_math_entrypoint_object(logbl)
 

libc/src/math/generic/CMakeLists.txt

DEPENDS
     .common_constants
     libc.src.__support.FPUtil.fputil
   COMPILE_OPTIONS
     -O3
     -Wno-c++17-extensions
 )
 
 add_entrypoint_object(
+  log1pf
+  SRCS
+    log1pf.cpp
+  HDRS
+    ../log1pf.h
+  DEPENDS
+    .common_constants
+    libc.src.__support.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O3
+    -Wno-c++17-extensions
+)
+
+add_entrypoint_object(
   log2f
   SRCS
     log2f.cpp
   HDRS
     ../log2f.h
   DEPENDS
     .common_constants
     libc.src.__support.FPUtil.fputil

libc/src/math/generic/log1pf.cpp

+//===-- Single-precision log1p(x) 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/log1pf.h"
+#include "common_constants.h" // Lookup table for (1/f)
+#include "src/__support/FPUtil/BasicOperations.h"
+#include "src/__support/FPUtil/FEnvUtils.h"
+#include "src/__support/FPUtil/FMA.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/__support/FPUtil/PolyEval.h"
+#include "src/__support/common.h"
+
+// This is an algorithm for log10(x) in single precision which is
+// correctly rounded for all rounding modes.
+// - An exhaustive test show that when x >= 2^45, log1pf(x) == logf(x)
+// for all rounding modes.
+// - When 2^(-8) <= |x| < 2^45, the sum (double(x) + 1.0) is exact,
+// so we can adapt the correctly rounded algorithm of logf to compute
+// log(double(x) + 1.0) correctly.  For more information about the logf
+// algorithm, see `libc/src/math/generic/logf.cpp`.
+// - When |x| < 2^(-8), we use a degree-6 polynomial in double precision
+// generated with Sollya using the following command:
+//   fpminimax(log(1 + x)/x, 5, [|D...|], [-2^-8; 2^-8]);
+
+namespace __llvm_libc {
+
+// Lookup table for log(f) = log(1 + n*2^(-7)) where n = 0..127.
+static constexpr double LOG_F[128] = {
+    0x0.0000000000000p+0, 0x1.fe02a6b106788p-8, 0x1.fc0a8b0fc03e3p-7,
+    0x1.7b91b07d5b11ap-6, 0x1.f829b0e783300p-6, 0x1.39e87b9febd5fp-5,
+    0x1.77458f632dcfcp-5, 0x1.b42dd711971bep-5, 0x1.f0a30c01162a6p-5,
+    0x1.16536eea37ae0p-4, 0x1.341d7961bd1d0p-4, 0x1.51b073f06183fp-4,
+    0x1.6f0d28ae56b4bp-4, 0x1.8c345d6319b20p-4, 0x1.a926d3a4ad563p-4,
+    0x1.c5e548f5bc743p-4, 0x1.e27076e2af2e5p-4, 0x1.fec9131dbeabap-4,
+    0x1.0d77e7cd08e59p-3, 0x1.1b72ad52f67a0p-3, 0x1.29552f81ff523p-3,
+    0x1.371fc201e8f74p-3, 0x1.44d2b6ccb7d1ep-3, 0x1.526e5e3a1b437p-3,
+    0x1.5ff3070a793d3p-3, 0x1.6d60fe719d21cp-3, 0x1.7ab890210d909p-3,
+    0x1.87fa06520c910p-3, 0x1.9525a9cf456b4p-3, 0x1.a23bc1fe2b563p-3,
+    0x1.af3c94e80bff2p-3, 0x1.bc286742d8cd6p-3, 0x1.c8ff7c79a9a21p-3,
+    0x1.d5c216b4fbb91p-3, 0x1.e27076e2af2e5p-3, 0x1.ef0adcbdc5936p-3,
+    0x1.fb9186d5e3e2ap-3, 0x1.0402594b4d040p-2, 0x1.0a324e27390e3p-2,
+    0x1.1058bf9ae4ad5p-2, 0x1.1675cababa60ep-2, 0x1.1c898c16999fap-2,
+    0x1.22941fbcf7965p-2, 0x1.2895a13de86a3p-2, 0x1.2e8e2bae11d30p-2,
+    0x1.347dd9a987d54p-2, 0x1.3a64c556945e9p-2, 0x1.404308686a7e3p-2,
+    0x1.4618bc21c5ec2p-2, 0x1.4be5f957778a0p-2, 0x1.51aad872df82dp-2,
+    0x1.5767717455a6cp-2, 0x1.5d1bdbf5809cap-2, 0x1.62c82f2b9c795p-2,
+    0x1.686c81e9b14aep-2, 0x1.6e08eaa2ba1e3p-2, 0x1.739d7f6bbd006p-2,
+    0x1.792a55fdd47a2p-2, 0x1.7eaf83b82afc3p-2, 0x1.842d1da1e8b17p-2,
+    0x1.89a3386c1425ap-2, 0x1.8f11e873662c7p-2, 0x1.947941c2116fap-2,
+    0x1.99d958117e08ap-2, 0x1.9f323ecbf984bp-2, 0x1.a484090e5bb0ap-2,
+    0x1.a9cec9a9a0849p-2, 0x1.af1293247786bp-2, 0x1.b44f77bcc8f62p-2,
+    0x1.b9858969310fbp-2, 0x1.beb4d9da71b7bp-2, 0x1.c3dd7a7cdad4dp-2,
+    0x1.c8ff7c79a9a21p-2, 0x1.ce1af0b85f3ebp-2, 0x1.d32fe7e00ebd5p-2,
+    0x1.d83e7258a2f3ep-2, 0x1.dd46a04c1c4a0p-2, 0x1.e24881a7c6c26p-2,
+    0x1.e744261d68787p-2, 0x1.ec399d2468cc0p-2, 0x1.f128f5faf06ecp-2,
+    0x1.f6123fa7028acp-2, 0x1.faf588f78f31ep-2, 0x1.ffd2e0857f498p-2,
+    0x1.02552a5a5d0fep-1, 0x1.04bdf9da926d2p-1, 0x1.0723e5c1cdf40p-1,
+    0x1.0986f4f573520p-1, 0x1.0be72e4252a82p-1, 0x1.0e44985d1cc8bp-1,
+    0x1.109f39e2d4c96p-1, 0x1.12f719593efbcp-1, 0x1.154c3d2f4d5e9p-1,
+    0x1.179eabbd899a0p-1, 0x1.19ee6b467c96ep-1, 0x1.1c3b81f713c24p-1,
+    0x1.1e85f5e7040d0p-1, 0x1.20cdcd192ab6dp-1, 0x1.23130d7bebf42p-1,
+    0x1.2555bce98f7cbp-1, 0x1.2795e1289b11ap-1, 0x1.29d37fec2b08ap-1,
+    0x1.2c0e9ed448e8bp-1, 0x1.2e47436e40268p-1, 0x1.307d7334f10bep-1,
+    0x1.32b1339121d71p-1, 0x1.34e289d9ce1d3p-1, 0x1.37117b54747b5p-1,
+    0x1.393e0d3562a19p-1, 0x1.3b68449fffc22p-1, 0x1.3d9026a7156fap-1,
+    0x1.3fb5b84d16f42p-1, 0x1.41d8fe84672aep-1, 0x1.43f9fe2f9ce67p-1,
+    0x1.4618bc21c5ec2p-1, 0x1.48353d1ea88dfp-1, 0x1.4a4f85db03ebbp-1,
+    0x1.4c679afccee39p-1, 0x1.4e7d811b75bb0p-1, 0x1.50913cc01686bp-1,
+    0x1.52a2d265bc5aap-1, 0x1.54b2467999497p-1, 0x1.56bf9d5b3f399p-1,
+    0x1.58cadb5cd7989p-1, 0x1.5ad404c359f2cp-1, 0x1.5cdb1dc6c1764p-1,
+    0x1.5ee02a9241675p-1, 0x1.60e32f44788d8p-1};
+
+namespace internal {
+
+// We don't need to treat denormal
+INLINE_FMA static inline float log(double x) {
+  constexpr double LOG_2 = 0x1.62e42fefa39efp-1;
+
+  using FPBits = typename fputil::FPBits<double>;
+  FPBits xbits(x);
+
+  if (xbits.is_zero()) {
+    return static_cast<float>(fputil::FPBits<float>::neg_inf());
+  }
+
+  if (xbits.uintval() > FPBits::MAX_NORMAL) {
+    if (xbits.get_sign() && !xbits.is_nan()) {
+      return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
+    }
+    return static_cast<float>(x);
+  }
+
+  double m = static_cast<double>(xbits.get_exponent());
+
+  // Set bits to 1.m
+  xbits.set_unbiased_exponent(0x3FF);
+  // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
+  // lookup tables.
+  int f_index =
+      xbits.get_mantissa() >> 45; // fputil::MantissaWidth<double>::VALUE - 7
+
+  FPBits f(xbits.val);
+  // Clear the lowest 45 bits.
+  f.bits &= ~0x0000'1FFF'FFFF'FFFFULL;
+
+  double d = static_cast<double>(xbits) - static_cast<double>(f);
+  d *= ONE_OVER_F[f_index];
+
+  double extra_factor = fputil::fma(m, LOG_2, LOG_F[f_index]);
+
+  double r = fputil::polyeval(d, extra_factor, 0x1.fffffffffffacp-1,
+                              -0x1.fffffffef9cb2p-2, 0x1.5555513bc679ap-2,
+                              -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
+
+  return static_cast<float>(r);
+}
+
+} // namespace internal
+
+INLINE_FMA
+LLVM_LIBC_FUNCTION(float, log1pf, (float x)) {
+  using FPBits = typename fputil::FPBits<float>;
+  FPBits xbits(x);
+  double xd = static_cast<double>(x);
+
+  if (xbits.get_exponent() >= -8) {
+    // Hard-to-round cases.
+    switch (xbits.uintval()) {
+    case 0x3b9315c8U: // x = 0x1.262b9p-8f
+      if (fputil::get_round() != FE_UPWARD)
+        return 0x1.25830cp-8f;
+      break;
+    case 0x3c6eb7afU: // x = 0x1.dd6f5ep-7f
+      if (fputil::get_round() == FE_UPWARD)
+        return 0x1.d9fd86p-7f;
+      return 0x1.d9fd84p-7f;
+    case 0x41078febU: // x = 0x1.0f1fd6p+3f
+      if (fputil::get_round() != FE_UPWARD)
+        return 0x1.1fcbcep+1f;
+      break;
+    case 0x5cd69e88U: // x = 0x1.ad3d1p+58f
+      if (fputil::get_round() != FE_UPWARD)
+        return 0x1.45c146p+5f;
+      break;
+    case 0x65d890d3U: // x = 0x1.b121a6p+76f
+      if (fputil::get_round() == FE_TONEAREST)
+        return 0x1.a9a3f2p+5f;
+      break;
+    case 0x6f31a8ecU: // x = 0x1.6351d8p+95f
+      if (fputil::get_round() == FE_TONEAREST)
+        return 0x1.08b512p+6f;
+      break;
+    case 0x7a17f30aU: // x = 0x1.2fe614p+117f
+      if (fputil::get_round() != FE_UPWARD)
+        return 0x1.451436p+6f;
+      break;
+    case 0xbc4d092cU: // x = -0x1.9a1258p-7f
+      if (fputil::get_round() == FE_TONEAREST)
+        return -0x1.9ca8bep-7f;
+      break;
+    case 0xbc657728U: // x = -0x1.caee5p-7f
+      if (fputil::get_round() != FE_DOWNWARD)
+        return -0x1.ce2cccp-7f;
+      break;
+    case 0xbd1d20afU: // x = -0x1.3a415ep-5f
+      int round_mode = fputil::get_round();
+      if (round_mode == FE_UPWARD || round_mode == FE_TOWARDZERO)
+        return -0x1.40711p-5f;
+      return -0x1.407112p-5f;
+    }
+
+    return internal::log(xd + 1.0);
+  }
+
+  // Hard-to round cases.
+  switch (xbits.uintval()) {
+  case 0x35400003U: // x = 0x1.800006p-21f
+    if (fputil::get_round() == FE_TONEAREST)
+      return 0x1.7ffffep-21f;
+    break;
+  case 0x3710001bU: // x = 0x1.200036p-17f
+    if (fputil::get_round() == FE_TONEAREST)
+      return 0x1.1fffe6p-17f;
+    break;
+  case 0xb53ffffdU: // x = -0x1.7ffffap-21f
+    if (fputil::get_round() != FE_DOWNWARD)
+      return -0x1.800002p-21f;
+    break;
+  case 0xb70fffe5U: // x = -0x1.1fffcap-17f
+    if (fputil::get_round() != FE_DOWNWARD)
+      return -0x1.20001ap-17f;
+    break;
+  case 0xbb0ec8c4U: // x = -0x1.1d9188p-9f
+    if (fputil::get_round() == FE_TONEAREST)
+      return -0x1.1de14ap-9f;
+    break;
+  }
+
+  double r;
+  // Polymial generated with Sollya:
+  // > fpminimax(log(1 + x)/x, 5, [|D...|], [-2^-8; 2^-8]);
+  r = fputil::polyeval(xd, -0x1p-1, 0x1.5555555515551p-2, -0x1.ffffffff82bdap-3,
+                       0x1.999b33348d3aep-3, -0x1.5556cae3adcc3p-3);
+  return static_cast<float>(fputil::fma(r, xd * xd, xd));
+}
+
+} // namespace __llvm_libc

libc/src/math/log1pf.h

+//===-- Implementation header for log1pf ------------------------*- 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_LOG1PF_H
+#define LLVM_LIBC_SRC_MATH_LOG1PF_H
+
+namespace __llvm_libc {
+
+float log1pf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LOG1PF_H

libc/test/src/math/CMakeLists.txt

add_fp_unittest(
   SRCS
     log10f_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.log10f
     libc.src.__support.FPUtil.fputil
 )
 
+add_fp_unittest(
+  log1pf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    log1pf_test.cpp
+  DEPENDS
+    libc.include.math
+    libc.src.math.log1pf
+    libc.src.__support.FPUtil.fputil
+)
+
 add_subdirectory(generic)
 add_subdirectory(exhaustive)
 add_subdirectory(differential_testing)

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

add_diff_binary(
   DEPENDS
     .single_input_single_output_diff
     libc.src.math.log10f
   COMPILE_OPTIONS
     -fno-builtin
 )
 
 add_diff_binary(
+  log1pf_perf
+  SRCS
+    log1pf_perf.cpp
+  DEPENDS
+    .single_input_single_output_diff
+    libc.src.math.log1pf
+  COMPILE_OPTIONS
+    -fno-builtin
+)
+
+add_diff_binary(
   log2f_diff
   SRCS
     log2f_diff.cpp
   DEPENDS
     .single_input_single_output_diff
     libc.src.math.log2f
   COMPILE_OPTIONS
     -fno-builtin

libc/test/src/math/differential_testing/log1pf_perf.cpp

+//===-- Differential test for log1pf --------------------------------------===//
+//
+// 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 "SingleInputSingleOutputDiff.h"
+
+#include "src/math/log1pf.h"
+
+#include <math.h>
+
+SINGLE_INPUT_SINGLE_OUTPUT_PERF(float, __llvm_libc::log1pf, ::log1pf,
+                                "log1pf_perf.log")

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

DEPENDS
     libc.include.math
     libc.src.math.log10f
     libc.src.__support.FPUtil.fputil
   LINK_OPTIONS
     -lpthread
 )
 
 add_fp_unittest(
+  log1pf_test
+  NO_RUN_POSTBUILD
+  NEED_MPFR
+  SUITE
+    libc_math_exhaustive_tests
+  SRCS
+    log1pf_test.cpp
+  DEPENDS
+    .exhaustive_test
+    libc.include.math
+    libc.src.math.log1pf
+    libc.src.__support.FPUtil.fputil
+  LINK_OPTIONS
+    -lpthread
+)
+
+add_fp_unittest(
   log2f_test
   NO_RUN_POSTBUILD
   NEED_MPFR
   SUITE
     libc_math_exhaustive_tests
   SRCS
     log2f_test.cpp
   DEPENDS
     .exhaustive_test
     libc.include.math
     libc.src.math.log2f
     libc.src.__support.FPUtil.fputil
   LINK_OPTIONS
     -lpthread
 )

libc/test/src/math/exhaustive/log1pf_test.cpp

+//===-- Exhaustive test for log1pf ----------------------------------------===//
+//
+// 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 "exhaustive_test.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/log1pf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+struct LlvmLibclog1pfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
+  void check(uint32_t start, uint32_t stop,
+             mpfr::RoundingMode rounding) override {
+    mpfr::ForceRoundingMode r(rounding);
+    uint32_t bits = start;
+    do {
+      FPBits xbits(bits);
+      float x = float(xbits);
+      EXPECT_MPFR_MATCH(mpfr::Operation::Log1p, x, __llvm_libc::log1pf(x), 0.5,
+                        rounding);
+    } while (bits++ < stop);
+  }
+};
+
+// Range: All non-negative;
+static constexpr uint32_t START = 0x0000'0000U;
+static constexpr uint32_t STOP = 0x7f80'0000U;
+// Range: [-1, 0];
+// static constexpr uint32_t START = 0x8000'0000U;
+// static constexpr uint32_t STOP  = 0xbf80'0000U;
+static constexpr int NUM_THREADS = 16;
+
+TEST_F(LlvmLibclog1pfExhaustiveTest, RoundNearestTieToEven) {
+  test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibclog1pfExhaustiveTest, RoundUp) {
+  test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibclog1pfExhaustiveTest, RoundDown) {
+  test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibclog1pfExhaustiveTest, RoundTowardZero) {
+  test_full_range(START, STOP, NUM_THREADS, mpfr::RoundingMode::TowardZero);
+}

libc/test/src/math/log1pf_test.cpp

+//===-- Unittests for log1pf ----------------------------------------------===//
+//
+// 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/FPUtil/FPBits.h"
+#include "src/math/log1pf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+#include "utils/UnitTest/Test.h"
+#include <math.h>
+
+#include <errno.h>
+#include <stdint.h>
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+DECLARE_SPECIAL_CONSTANTS(float)
+
+TEST(LlvmLibclog1pfTest, SpecialNumbers) {
+  EXPECT_FP_EQ(aNaN, __llvm_libc::log1pf(aNaN));
+  EXPECT_FP_EQ(inf, __llvm_libc::log1pf(inf));
+  EXPECT_TRUE(FPBits((__llvm_libc::log1pf(neg_inf))).is_nan());
+  EXPECT_FP_EQ(zero, __llvm_libc::log1pf(0.0f));
+  EXPECT_FP_EQ(neg_zero, __llvm_libc::log1pf(-0.0f));
+  EXPECT_FP_EQ(neg_inf, __llvm_libc::log1pf(-1.0f));
+}
+
+TEST(LlvmLibclog1pfTest, TrickyInputs) {
+  constexpr int N = 20;
+  constexpr uint32_t INPUTS[N] = {
+      0x35c00006U, /*0x1.80000cp-20f*/
+      0x35400003U, /*0x1.800006p-21f*/
+      0x3640000cU, /*0x1.800018p-19f*/
+      0x36c00018U, /*0x1.80003p-18f*/
+      0x3710001bU, /*0x1.200036p-17f*/
+      0x37400030U, /*0x1.80006p-17f*/
+      0x3770004bU, /*0x1.e00096p-17f*/
+      0x3b9315c8U, /*0x1.262b9p-8f*/
+      0x3c6eb7afU, /*0x1.dd6f5ep-7f*/
+      0x41078febU, /*0x1.0f1fd6p+3f*/
+      0x5cd69e88U, /*0x1.ad3d1p+58f*/
+      0x65d890d3U, /*0x1.b121a6p+76f*/
+      0x6f31a8ecU, /*0x1.6351d8p+95f*/
+      0x7a17f30aU, /*0x1.2fe614p+117f*/
+      0xb53ffffdU, /*-0x1.7ffffap-21f*/
+      0xb70fffe5U, /*-0x1.1fffcap-17f*/
+      0xbb0ec8c4U, /*-0x1.1d9188p-9f*/
+      0xbc4d092cU, /*-0x1.9a1258p-7f*/
+      0xbc657728U, /*-0x1.caee5p-7f*/
+      0xbd1d20afU, /*-0x1.3a415ep-5f*/
+  };
+  for (int i = 0; i < N; ++i) {
+    float x = float(FPBits(INPUTS[i]));
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
+                                   __llvm_libc::log1pf(x), 0.5);
+  }
+}
+
+TEST(LlvmLibclog1pfTest, InFloatRange) {
+  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t STEP = UINT32_MAX / COUNT;
+  for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
+    float x = float(FPBits(v));
+    if (isnan(x) || isinf(x))
+      continue;
+    errno = 0;
+    float result = __llvm_libc::log1pf(x);
+    // If the computation resulted in an error or did not produce valid result
+    // in the single-precision floating point range, then ignore comparing with
+    // MPFR result as MPFR can still produce valid results because of its
+    // wider precision.
+    if (isnan(result) || isinf(result) || errno != 0)
+      continue;
+    ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
+                                   __llvm_libc::log1pf(x), 0.5);
+  }
+}

libc/utils/MPFRWrapper/MPFRUtils.h

enum class Operation : int {
   Cos,
   Exp,
   Exp2,
   Expm1,
   Floor,
   Log,
   Log2,
   Log10,
+  Log1p,
   Mod2PI,
   ModPIOver2,
   ModPIOver4,
   Round,
   Sin,
   Sqrt,
   Tan,
   Trunc,

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   }
 
   MPFRNumber log10() const {
     MPFRNumber result(*this);
     mpfr_log10(result.value, value, mpfr_rounding);
     return result;
   }
 
+  MPFRNumber log1p() const {
+    MPFRNumber result(*this);
+    mpfr_log1p(result.value, value, mpfr_rounding);
+    return result;
+  }
+
   MPFRNumber remquo(const MPFRNumber &divisor, int &quotient) {
     MPFRNumber remainder(*this);
     long q;
     mpfr_remquo(remainder.value, &q, value, divisor.value, mpfr_rounding);
     quotient = q;
     return remainder;
   }
 
unary_operation(Operation op, InputType input, unsigned int precision,
   case Operation::Floor:
     return mpfrInput.floor();
   case Operation::Log:
     return mpfrInput.log();
   case Operation::Log2:
     return mpfrInput.log2();
   case Operation::Log10:
     return mpfrInput.log10();
+  case Operation::Log1p:
+    return mpfrInput.log1p();
   case Operation::Mod2PI:
     return mpfrInput.mod_2pi();
   case Operation::ModPIOver2:
     return mpfrInput.mod_pi_over_2();
   case Operation::ModPIOver4:
     return mpfrInput.mod_pi_over_4();
   case Operation::Round:
     return mpfrInput.round();