Implement C23 log2p1

C23 adds various <math.h> function families originally defined in TS
18661-4.  Add the log2p1 functions (log2(1+x): like log1p, but for
base-2 logarithms).

This illustrates the intended structure of implementations of all
these function families: define them initially with a type-generic
template implementation.  If someone wishes to add type-specific
implementations, it is likely such implementations can be both faster
and more accurate than the type-generic one and can then override it
for types for which they are implemented (adding benchmarks would be
desirable in such cases to demonstrate that a new implementation is
indeed faster).

The test inputs are copied from those for log1p.  Note that these
changes make gen-auto-libm-tests depend on MPFR 4.2 (or later).

The bulk of the changes are fairly generic for any such new function.
(sysdeps/powerpc/nofpu/Makefile only needs changing for those
type-generic templates that use fabs.)

Tested for x86_64 and x86, and with build-many-glibcs.py.

1 files changed, 11 insertions, 1 deletions

diff --git a/math/test-tgmath.c b/math/test-tgmath.c
index 93efd8b..141e96b 100644
--- a/math/test-tgmath.c
+++ b/math/test-tgmath.c
@@ -48,7 +48,7 @@ volatile int count_cdouble;
 volatile int count_cfloat;
 volatile int count_cldouble;
 
-#define NCALLS     158
+#define NCALLS     160
 #define NCALLS_INT 4
 #define NCCALLS    47
 
@@ -255,6 +255,7 @@ F(compile_test) (void)
   a = exp2 (exp2 (x));
   a = exp10 (exp10 (x));
   b = log2 (log2 (a));
+  a = log2p1 (log2p1 (x));
   a = pow (pow (x, a), pow (c, b));
   b = sqrt (sqrt (a));
   a = hypot (hypot (x, b), hypot (c, a));
@@ -368,6 +369,7 @@ F(compile_test) (void)
       a = exp2 (y);
       a = exp10 (y);
       a = log2 (y);
+      a = log2p1 (y);
       a = pow (y, y);
       a = sqrt (y);
       a = hypot (y, y);
@@ -642,6 +644,14 @@ TYPE
 }
 
 TYPE
+(F(log2p1)) (TYPE x)
+{
+  ++count;
+  P ();
+  return x;
+}
+
+TYPE
 (F(pow)) (TYPE x, TYPE y)
 {
   ++count;