[PATCH v2 0/6] Math static build fixes

[PATCH v2 0/6] Math static build fixes

[Adhemerval Zanella]

Some recent math optimizations remove some symbols from the static build
and due to the limited static build check, along with a --disable-shared
being broken for some time [1]; this issue has slipped some releases.

Although the fix is straightforward, I added an extra framework to
enable static build for select math libraries using the generic type
framework (which autogenerated the tests for all supported types using
the C template files). This should help with future static build tests.

Although the second and fifth patches should be back portable, I also
added some patches to removed the i686 assembly optimizations.

[1] https://sourceware.org/bugzilla/show_bug.cgi?id=20845

Adhemerval Zanella (6):
  math: Add support for auto static math tests
  math: Fix i386 and m68k fmod/fmodf on static build (BZ 31488)
  i386: Use generic fmod
  i386: Use generic fmodf
  math: Fix i386 and m68k exp10 on static build
  i386: Use generic exp10

 math/Makefile                             | 108 +++++++++++++++++++++-
 math/test-double-static.h                 |   1 +
 math/test-float-static.h                  |   1 +
 math/test-float128-static.h               |   1 +
 math/test-float32-static.h                |   1 +
 math/test-float32x-static.h               |   1 +
 math/test-float64-static.h                |   1 +
 math/test-float64x-static.h               |   1 +
 math/test-ibm128-static.h                 |   1 +
 math/test-ldouble-static.h                |   1 +
 sysdeps/i386/fpu/Versions                 |   5 +
 sysdeps/i386/fpu/e_exp10.S                |  51 ----------
 sysdeps/i386/fpu/e_exp10.c                |   2 +
 sysdeps/i386/fpu/e_exp_data.c             |   1 -
 sysdeps/i386/fpu/e_fmod.S                 |  18 ----
 sysdeps/i386/fpu/e_fmod.c                 |   2 +
 sysdeps/i386/fpu/e_fmodf.S                |  18 ----
 sysdeps/i386/fpu/e_fmodf.c                |   2 +
 sysdeps/i386/fpu/math_err.c               |   1 -
 sysdeps/i386/fpu/w_exp10_compat.c         |   3 -
 sysdeps/i386/fpu/w_fmod_compat.c          |  14 ---
 sysdeps/i386/fpu/w_fmodf_compat.c         |  14 ---
 sysdeps/ieee754/dbl-64/e_exp10.c          |   7 +-
 sysdeps/ieee754/dbl-64/e_fmod.c           |   5 +-
 sysdeps/ieee754/flt-32/e_fmodf.c          |   5 +-
 sysdeps/ieee754/ldbl-opt/s_ldexpl.c       |   4 +-
 sysdeps/m68k/m680x0/fpu/w_exp10_compat.c  |   9 +-
 sysdeps/m68k/m680x0/fpu/w_fmod_compat.c   |   5 +-
 sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c  |   7 +-
 sysdeps/mach/hurd/i386/libm.abilist       |   3 +
 sysdeps/unix/sysv/linux/i386/libm.abilist |   3 +
 31 files changed, 161 insertions(+), 135 deletions(-)
 create mode 100644 math/test-double-static.h
 create mode 100644 math/test-float-static.h
 create mode 100644 math/test-float128-static.h
 create mode 100644 math/test-float32-static.h
 create mode 100644 math/test-float32x-static.h
 create mode 100644 math/test-float64-static.h
 create mode 100644 math/test-float64x-static.h
 create mode 100644 math/test-ibm128-static.h
 create mode 100644 math/test-ldouble-static.h
 delete mode 100644 sysdeps/i386/fpu/e_exp10.S
 create mode 100644 sysdeps/i386/fpu/e_exp10.c
 delete mode 100644 sysdeps/i386/fpu/e_exp_data.c
 delete mode 100644 sysdeps/i386/fpu/e_fmod.S
 create mode 100644 sysdeps/i386/fpu/e_fmod.c
 delete mode 100644 sysdeps/i386/fpu/e_fmodf.S
 create mode 100644 sysdeps/i386/fpu/e_fmodf.c
 delete mode 100644 sysdeps/i386/fpu/math_err.c
 delete mode 100644 sysdeps/i386/fpu/w_exp10_compat.c
 delete mode 100644 sysdeps/i386/fpu/w_fmod_compat.c
 delete mode 100644 sysdeps/i386/fpu/w_fmodf_compat.c

-- 
2.34.1

[PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella]

It basically copy the already in place rules for dynamic tests
for auto-generated math tests for all support types.  To avoid
the need to duplicate .inc files, a .SECONDEXPANSION rules is
adeed for the gen-libm-test.py generation.
---
 math/Makefile               | 104 +++++++++++++++++++++++++++++++++++-
 math/test-double-static.h   |   1 +
 math/test-float-static.h    |   1 +
 math/test-float128-static.h |   1 +
 math/test-float32-static.h  |   1 +
 math/test-float32x-static.h |   1 +
 math/test-float64-static.h  |   1 +
 math/test-float64x-static.h |   1 +
 math/test-ibm128-static.h   |   1 +
 math/test-ldouble-static.h  |   1 +
 10 files changed, 111 insertions(+), 2 deletions(-)
 create mode 100644 math/test-double-static.h
 create mode 100644 math/test-float-static.h
 create mode 100644 math/test-float128-static.h
 create mode 100644 math/test-float32-static.h
 create mode 100644 math/test-float32x-static.h
 create mode 100644 math/test-float64-static.h
 create mode 100644 math/test-float64x-static.h
 create mode 100644 math/test-ibm128-static.h
 create mode 100644 math/test-ldouble-static.h

diff --git a/math/Makefile b/math/Makefile
index 79ef4ebb65..aef9cec1a1 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -274,8 +274,10 @@ endif
 
 libm-vec-tests = $(addprefix test-,$(libmvec-tests))
 libm-test-support = $(foreach t,$(test-types),libm-test-support-$(t))
-test-extras += $(libm-test-support)
-extra-test-objs += $(addsuffix .o, $(libm-test-support))
+libm-test-support-static = $(foreach t,$(test-types),libm-test-support-$(t)-static)
+test-extras += $(libm-test-support) $(libm-test-support-static)
+extra-test-objs += $(addsuffix .o, $(libm-test-support)) \
+		   $(addsuffix .o, $(libm-test-support-static))
 libm-vec-test-wrappers = $(addsuffix -wrappers, $(libm-vec-tests))
 test-extras += $(libm-vec-test-wrappers)
 extra-test-objs += $(addsuffix .o, $(libm-vec-test-wrappers))
@@ -364,6 +366,64 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 	$(make-target-directory)
 	$(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out$* -C $@
 
+
+libm-test-funcs-auto-static =
+libm-test-funcs-noauto-static =
+libm-test-funcs-compat-static =
+libm-test-funcs-narrow-static =
+libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
+
+libm-test-c-auto-static = $(foreach f,$(libm-test-funcs-auto-static),libm-test-$(f)-static.c)
+libm-test-c-noauto-static = $(foreach f,$(libm-test-funcs-noauto-static),libm-test-$(f)-static.c)
+libm-test-c-narrow-static = $(foreach f,$(libm-test-funcs-narrow-static),\
+				 libm-test-narrow-$(f)-static.c)
+generated += $(libm-test-c-auto-static) $(libm-test-c-noauto-static) $(libm-test-c-narrow-static)
+
+libm-tests-normal-static = $(foreach t,$(libm-tests-base-normal),\
+				$(foreach f,$(libm-test-funcs-all-static),\
+					    $(t)-$(f)-static))
+libm-tests-narrow-static = $(foreach t,$(libm-tests-base-narrow-static),\
+				$(foreach f,$(libm-test-funcs-narrow-static),\
+					    $(t)-$(f)-static))
+libm-tests-vector-static = $(foreach t,$(libmvec-tests-static),\
+				$(foreach f,$($(t)-funcs),test-$(t)-$(f)-static))
+libm-tests-static = $(libm-tests-normal-static) $(libm-tests-narrow-static) $(libm-tests-vector-static)
+libm-tests-for-type-static = $(foreach f,$(libm-test-funcs-all-static),\
+					 test-$(1)-$(f)-static test-i$(1)-$(f)-static) \
+			     $(filter test-$(1)-%,$(libm-tests-vector-static) \
+						  $(libm-tests-narrow-static))
+
+libm-tests.o += $(addsuffix .o,$(libm-tests-static))
+
+tests-static += $(libm-tests-static)
+generated += $(addsuffix .c,$(libm-tests)) \
+	     $(foreach t,$(test-types),libm-test-support-$(t)-static.c)
+
+libm-test-c-auto-obj-static = $(addprefix $(objpfx),$(libm-test-c-auto-static))
+libm-test-c-noauto-obj-static = $(addprefix $(objpfx),$(libm-test-c-noauto-static))
+libm-test-c-narrow-obj-static = $(addprefix $(objpfx),$(libm-test-c-narrow-static))
+
+# Use the same input test definitions for both dynamic and static tests.
+.SECONDEXPANSION:
+$(libm-test-c-noauto-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
+							 gen-libm-test.py
+	$(make-target-directory)
+	$(PYTHON) gen-libm-test.py -c $< -a /dev/null -C $@
+
+.SECONDEXPANSION:
+$(libm-test-c-auto-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
+						       gen-libm-test.py \
+						       auto-libm-test-out$$(subst -static,,%)
+	$(make-target-directory)
+	$(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out`echo $* | sed 's/-static//'` -C $@
+
+.SECONDEXPANSION:
+$(libm-test-c-narrow-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
+							 gen-libm-test.py \
+							 auto-libm-test-out$$(subst -static,,%)
+	$(make-target-directory)
+	$(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out`echo $* | sed 's/-static//'` -C $@
+
 # Tests for totalorder compat symbols reuse the table of tests as
 # processed by gen-libm-test.py, so add dependencies on the generated
 # .c files.
@@ -505,6 +565,18 @@ $(foreach t,$(libm-tests-normal),$(objpfx)$(t).c): $(objpfx)test-%.c:
 	  echo "#include <libm-test-$$func.c>"; \
 	) > $@
 
+$(foreach t,$(libm-tests-normal-static),$(objpfx)$(t).c): $(objpfx)test-%.c:
+	type_func=$*; \
+	type=$${type_func%%-*}; \
+	func=$${type_func#*-}; \
+	( \
+	  echo "#include <test-$$type.h>"; \
+	  echo "#include <test-math-exceptions.h>"; \
+	  echo "#include <test-math-errno.h>"; \
+	  echo "#include <test-math-scalar.h>"; \
+	  echo "#include <libm-test-$$func.c>"; \
+	) > $@
+
 $(foreach t,$(libm-tests-narrow),$(objpfx)$(t).c): $(objpfx)test-%.c:
 	type_pair_func=$*; \
 	type_pair=$${type_pair_func%-*}; \
@@ -539,6 +611,13 @@ $(foreach t,$(test-types),\
 	  echo "#include <libm-test-support.c>"; \
 	) > $@
 
+$(foreach t,$(test-types),\
+	    $(objpfx)libm-test-support-$(t)-static.c): $(objpfx)libm-test-support-%.c:
+	( \
+	  echo "#include <test-$*.h>"; \
+	  echo "#include <libm-test-support.c>"; \
+	) > $@
+
 $(addprefix $(objpfx), $(libm-tests.o)): $(objpfx)libm-test-ulps.h
 
 define o-iterator-doit
@@ -548,6 +627,13 @@ endef
 object-suffixes-left := $(libm-tests-base)
 include $(o-iterator)
 
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all-static),\
+	    $(objpfx)$(o)-$(f)-static.o): $(objpfx)$(o)%.o: $(objpfx)libm-test%.c
+endef
+object-suffixes-left := $(libm-tests-base)
+include $(o-iterator)
+
 define o-iterator-doit
 $(foreach f,$(libm-test-funcs-narrow),\
 	    $(objpfx)$(o)-$(f).o): $(objpfx)$(o)%.o: \
@@ -563,6 +649,13 @@ endef
 object-suffixes-left := $(libm-tests-base-normal)
 include $(o-iterator)
 
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all-static),\
+	    $(objpfx)$(o)-$(f)-static.o): CFLAGS += $(libm-test-no-inline-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-normal)
+include $(o-iterator)
+
 define o-iterator-doit
 $(foreach f,$(libm-test-funcs-narrow),\
 	    $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-no-inline-cflags)
@@ -584,6 +677,13 @@ endef
 object-suffixes-left := $(test-types)
 include $(o-iterator)
 
+define o-iterator-doit
+$(addprefix $(objpfx),\
+	    $(call libm-tests-for-type-static,$(o))): $(objpfx)libm-test-support-$(o)-static.o
+endef
+object-suffixes-left := $(test-types)
+include $(o-iterator)
+
 define o-iterator-doit
 $(objpfx)libm-test-support-$(o).o: CFLAGS += $(libm-test-no-inline-cflags)
 endef
diff --git a/math/test-double-static.h b/math/test-double-static.h
new file mode 100644
index 0000000000..d53f46819f
--- /dev/null
+++ b/math/test-double-static.h
@@ -0,0 +1 @@
+#include "test-double.h"
diff --git a/math/test-float-static.h b/math/test-float-static.h
new file mode 100644
index 0000000000..7834c9e1f1
--- /dev/null
+++ b/math/test-float-static.h
@@ -0,0 +1 @@
+#include "test-float.h"
diff --git a/math/test-float128-static.h b/math/test-float128-static.h
new file mode 100644
index 0000000000..5f8206456a
--- /dev/null
+++ b/math/test-float128-static.h
@@ -0,0 +1 @@
+#include "test-float128.h"
diff --git a/math/test-float32-static.h b/math/test-float32-static.h
new file mode 100644
index 0000000000..2df27d1ca0
--- /dev/null
+++ b/math/test-float32-static.h
@@ -0,0 +1 @@
+#include "test-float32.h"
diff --git a/math/test-float32x-static.h b/math/test-float32x-static.h
new file mode 100644
index 0000000000..62f78b49d8
--- /dev/null
+++ b/math/test-float32x-static.h
@@ -0,0 +1 @@
+#include "test-float32x.h"
diff --git a/math/test-float64-static.h b/math/test-float64-static.h
new file mode 100644
index 0000000000..807c174df1
--- /dev/null
+++ b/math/test-float64-static.h
@@ -0,0 +1 @@
+#include "test-float64.h"
diff --git a/math/test-float64x-static.h b/math/test-float64x-static.h
new file mode 100644
index 0000000000..a7801dbc10
--- /dev/null
+++ b/math/test-float64x-static.h
@@ -0,0 +1 @@
+#include "test-float64x.h"
diff --git a/math/test-ibm128-static.h b/math/test-ibm128-static.h
new file mode 100644
index 0000000000..b66a57050b
--- /dev/null
+++ b/math/test-ibm128-static.h
@@ -0,0 +1 @@
+#include "test-ibm128.h"
diff --git a/math/test-ldouble-static.h b/math/test-ldouble-static.h
new file mode 100644
index 0000000000..beabedb817
--- /dev/null
+++ b/math/test-ldouble-static.h
@@ -0,0 +1 @@
+#include "test-ldouble.h"
-- 
2.34.1

[PATCH v2 2/6] math: Fix i386 and m68k fmod/fmodf on static build (BZ 31488)

[Adhemerval Zanella]

The commit 16439f419b removed the static fmod/fmodf on i386 and
m68k with and empty w_fmod.c (required for the ABIs that uses
the newly implementation).    This patch fixes by adding the
required symbols on the arch-specific w_fmod{f}_compat.c
implementation.

To statically build fmod fails on some ABI (alpha, s390, sparc)
because it does not export the ldexpf128, this is also fixed
by this patch.

Checked on i686-linux-gnu and with a build for m68k-linux-gnu.
I also checked that a stack build using fmod/fmodf correctly
resolves on both ABIs.
---
 math/Makefile                            | 4 +++-
 sysdeps/i386/fpu/w_fmod_compat.c         | 7 ++++---
 sysdeps/i386/fpu/w_fmodf_compat.c        | 7 ++++---
 sysdeps/ieee754/ldbl-opt/s_ldexpl.c      | 4 ++--
 sysdeps/m68k/m680x0/fpu/w_fmod_compat.c  | 5 +++--
 sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c | 7 ++++---
 6 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/math/Makefile b/math/Makefile
index aef9cec1a1..fbb2987248 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -368,7 +368,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 
 
 libm-test-funcs-auto-static =
-libm-test-funcs-noauto-static =
+libm-test-funcs-noauto-static = \
+  fmod \
+  # libm-test-funcs-noauto-static
 libm-test-funcs-compat-static =
 libm-test-funcs-narrow-static =
 libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
diff --git a/sysdeps/i386/fpu/w_fmod_compat.c b/sysdeps/i386/fpu/w_fmod_compat.c
index 5ac9995ffd..528bfc2a13 100644
--- a/sysdeps/i386/fpu/w_fmod_compat.c
+++ b/sysdeps/i386/fpu/w_fmod_compat.c
@@ -7,8 +7,9 @@
 # define LIBM_SVID_COMPAT 1
 # undef compat_symbol
 # define compat_symbol(a, b, c, d)
-#endif
-#include <math/w_fmod_compat.c>
-#ifdef SHARED
+# include <math/w_fmod_compat.c>
 libm_alias_double (__fmod_compat, fmod)
+#else
+#include <math-type-macros-double.h>
+#include <w_fmod_template.c>
 #endif
diff --git a/sysdeps/i386/fpu/w_fmodf_compat.c b/sysdeps/i386/fpu/w_fmodf_compat.c
index cc417e07d3..5a61693e51 100644
--- a/sysdeps/i386/fpu/w_fmodf_compat.c
+++ b/sysdeps/i386/fpu/w_fmodf_compat.c
@@ -7,8 +7,9 @@
 # define LIBM_SVID_COMPAT 1
 # undef compat_symbol
 # define compat_symbol(a, b, c, d)
-#endif
-#include <math/w_fmodf_compat.c>
-#ifdef SHARED
+# include <math/w_fmodf_compat.c>
 libm_alias_float (__fmod_compat, fmod)
+#else
+#include <math-type-macros-float.h>
+#include <w_fmod_template.c>
 #endif
diff --git a/sysdeps/ieee754/ldbl-opt/s_ldexpl.c b/sysdeps/ieee754/ldbl-opt/s_ldexpl.c
index 1afbe7d8ad..932cc4341c 100644
--- a/sysdeps/ieee754/ldbl-opt/s_ldexpl.c
+++ b/sysdeps/ieee754/ldbl-opt/s_ldexpl.c
@@ -17,13 +17,13 @@
    License along with the GNU C Library; if not, see
    <https://www.gnu.org/licenses/>.  */
 
-#if IS_IN (libc)
+#if IS_IN (libc) && defined SHARED
 # define declare_mgen_alias(f,t)
 #endif
 #include <math-type-macros-ldouble.h>
 #include <s_ldexp_template.c>
 
-#if IS_IN (libc)
+#if IS_IN (libc) && defined SHARED
 long_double_symbol (libc, __ldexpl, ldexpl);
 long_double_symbol (libc, __wrap_scalbnl, scalbnl);
 #endif
diff --git a/sysdeps/m68k/m680x0/fpu/w_fmod_compat.c b/sysdeps/m68k/m680x0/fpu/w_fmod_compat.c
index 527d4fbed2..57f38091e6 100644
--- a/sysdeps/m68k/m680x0/fpu/w_fmod_compat.c
+++ b/sysdeps/m68k/m680x0/fpu/w_fmod_compat.c
@@ -7,8 +7,9 @@
 # define LIBM_SVID_COMPAT 1
 # undef compat_symbol
 # define compat_symbol(a, b, c, d)
-#endif
 #include <math/w_fmod_compat.c>
-#ifdef SHARED
 libm_alias_double (__fmod_compat, fmod)
+#else
+#include <math-type-macros-double.h>
+#include <w_fmod_template.c>
 #endif
diff --git a/sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c b/sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c
index 5043586b91..88db07f443 100644
--- a/sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c
+++ b/sysdeps/m68k/m680x0/fpu/w_fmodf_compat.c
@@ -7,8 +7,9 @@
 # define LIBM_SVID_COMPAT 1
 # undef compat_symbol
 # define compat_symbol(a, b, c, d)
-#endif
-#include <math/w_fmodf_compat.c>
-#ifdef SHARED
+# include <math/w_fmodf_compat.c>
 libm_alias_float (__fmod_compat, fmod)
+#else
+#include <math-type-macros-float.h>
+#include <w_fmod_template.c>
 #endif
-- 
2.34.1

[PATCH v2 3/6] i386: Use generic fmod

[Adhemerval Zanella]

The benchtest results shows a slight improvement (Ryzen 5900, gcc
13.2.1):

* sysdeps/i386/fpu/e_fmod.S:
  "fmod": {
   "subnormals": {
    "duration": 3.68855e+09,
    "iterations": 2.12608e+08,
    "max": 62.012,
    "min": 16.798,
    "mean": 17.349
   },
   "normal": {
    "duration": 3.88459e+09,
    "iterations": 7.168e+06,
    "max": 2879.12,
    "min": 16.909,
    "mean": 541.934
   },
   "close-exponents": {
    "duration": 3.692e+09,
    "iterations": 1.96608e+08,
    "max": 66.452,
    "min": 16.835,
    "mean": 18.7785
   }
  }

* generic
  "fmod": {
   "subnormals": {
    "duration": 3.68645e+09,
    "iterations": 2.2848e+08,
    "max": 66.896,
    "min": 15.91,
    "mean": 16.1347
   },
   "normal": {
    "duration": 4.1455e+09,
    "iterations": 8.192e+06,
    "max": 3376.18,
    "min": 15.873,
    "mean": 506.043
   },
   "close-exponents": {
    "duration": 3.70197e+09,
    "iterations": 2.08896e+08,
    "max": 69.597,
    "min": 15.947,
    "mean": 17.7216
   }
  }
---
 sysdeps/i386/fpu/Versions                 |  4 ++++
 sysdeps/i386/fpu/e_fmod.S                 | 18 ------------------
 sysdeps/i386/fpu/e_fmod.c                 |  2 ++
 sysdeps/i386/fpu/math_err.c               |  1 -
 sysdeps/i386/fpu/w_fmod_compat.c          | 15 ---------------
 sysdeps/ieee754/dbl-64/e_fmod.c           |  5 ++++-
 sysdeps/mach/hurd/i386/libm.abilist       |  1 +
 sysdeps/unix/sysv/linux/i386/libm.abilist |  1 +
 8 files changed, 12 insertions(+), 35 deletions(-)
 delete mode 100644 sysdeps/i386/fpu/e_fmod.S
 create mode 100644 sysdeps/i386/fpu/e_fmod.c
 delete mode 100644 sysdeps/i386/fpu/math_err.c
 delete mode 100644 sysdeps/i386/fpu/w_fmod_compat.c

diff --git a/sysdeps/i386/fpu/Versions b/sysdeps/i386/fpu/Versions
index a2eec371f1..d37bc1eae6 100644
--- a/sysdeps/i386/fpu/Versions
+++ b/sysdeps/i386/fpu/Versions
@@ -3,4 +3,8 @@ libm {
     # functions used in inline functions or macros
     __expl; __expm1l;
   }
+  GLIBC_2.40 {
+    # No SVID compatible error handling.
+    fmod;
+  }
 }
diff --git a/sysdeps/i386/fpu/e_fmod.S b/sysdeps/i386/fpu/e_fmod.S
deleted file mode 100644
index 86ac1bcfaf..0000000000
--- a/sysdeps/i386/fpu/e_fmod.S
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Public domain.
- */
-
-#include <machine/asm.h>
-#include <libm-alias-finite.h>
-
-ENTRY(__ieee754_fmod)
-	fldl	12(%esp)
-	fldl	4(%esp)
-1:	fprem
-	fstsw	%ax
-	sahf
-	jp	1b
-	fstp	%st(1)
-	ret
-END (__ieee754_fmod)
-libm_alias_finite (__ieee754_fmod, __fmod)
diff --git a/sysdeps/i386/fpu/e_fmod.c b/sysdeps/i386/fpu/e_fmod.c
new file mode 100644
index 0000000000..3625758f97
--- /dev/null
+++ b/sysdeps/i386/fpu/e_fmod.c
@@ -0,0 +1,2 @@
+#define FMOD_VERSION GLIBC_2_40
+#include <sysdeps/ieee754/dbl-64/e_fmod.c>
diff --git a/sysdeps/i386/fpu/math_err.c b/sysdeps/i386/fpu/math_err.c
deleted file mode 100644
index 1cc8931700..0000000000
--- a/sysdeps/i386/fpu/math_err.c
+++ /dev/null
@@ -1 +0,0 @@
-/* Not needed.  */
diff --git a/sysdeps/i386/fpu/w_fmod_compat.c b/sysdeps/i386/fpu/w_fmod_compat.c
deleted file mode 100644
index 528bfc2a13..0000000000
--- a/sysdeps/i386/fpu/w_fmod_compat.c
+++ /dev/null
@@ -1,15 +0,0 @@
-/* i386 provides an optimized __ieee752_fmod.  */
-#include <math-svid-compat.h>
-#ifdef SHARED
-# undef SHLIB_COMPAT
-# define SHLIB_COMPAT(a, b, c) 1
-# undef LIBM_SVID_COMPAT
-# define LIBM_SVID_COMPAT 1
-# undef compat_symbol
-# define compat_symbol(a, b, c, d)
-# include <math/w_fmod_compat.c>
-libm_alias_double (__fmod_compat, fmod)
-#else
-#include <math-type-macros-double.h>
-#include <w_fmod_template.c>
-#endif
diff --git a/sysdeps/ieee754/dbl-64/e_fmod.c b/sysdeps/ieee754/dbl-64/e_fmod.c
index b33cfb1223..7651cd212a 100644
--- a/sysdeps/ieee754/dbl-64/e_fmod.c
+++ b/sysdeps/ieee754/dbl-64/e_fmod.c
@@ -175,7 +175,10 @@ __fmod (double x, double y)
 strong_alias (__fmod, __ieee754_fmod)
 libm_alias_finite (__ieee754_fmod, __fmod)
 #if LIBM_SVID_COMPAT
-versioned_symbol (libm, __fmod, fmod, GLIBC_2_38);
+# ifndef FMOD_VERSION
+#  define FMOD_VERSION GLIBC_2_38
+# endif
+versioned_symbol (libm, __fmod, fmod, FMOD_VERSION);
 libm_alias_double_other (__fmod, fmod)
 #else
 libm_alias_double (__fmod, fmod)
diff --git a/sysdeps/mach/hurd/i386/libm.abilist b/sysdeps/mach/hurd/i386/libm.abilist
index 8f40ddb150..30665f8b1a 100644
--- a/sysdeps/mach/hurd/i386/libm.abilist
+++ b/sysdeps/mach/hurd/i386/libm.abilist
@@ -1181,3 +1181,4 @@ GLIBC_2.35 fsqrt F
 GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
+GLIBC_2.40 fmod F
diff --git a/sysdeps/unix/sysv/linux/i386/libm.abilist b/sysdeps/unix/sysv/linux/i386/libm.abilist
index 5d89aaa08e..44932f111d 100644
--- a/sysdeps/unix/sysv/linux/i386/libm.abilist
+++ b/sysdeps/unix/sysv/linux/i386/libm.abilist
@@ -1188,3 +1188,4 @@ GLIBC_2.35 fsqrt F
 GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
+GLIBC_2.40 fmod F
-- 
2.34.1

[PATCH v2 4/6] i386: Use generic fmodf

[Adhemerval Zanella]

The resulting performance is similiar (Ryzen 5900, gcc 13.2.1):

* sysdeps/i386/fpu/e_fmodf.S
  "fmodf": {
   "subnormals": {
    "duration": 3.68732e+09,
    "iterations": 2.2912e+08,
    "max": 71.447,
    "min": 15.836,
    "mean": 16.0934
   },
   "normal": {
    "duration": 3.75848e+09,
    "iterations": 5.5296e+07,
    "max": 273.208,
    "min": 15.725,
    "mean": 67.9702
   },
   "close-exponents": {
    "duration": 3.69035e+09,
    "iterations": 2.07872e+08,
    "max": 64.454,
    "min": 15.762,
    "mean": 17.753
   }
  }

* master
  "fmodf": {
   "subnormals": {
    "duration": 3.6863e+09,
    "iterations": 2.23616e+08,
    "max": 65.453,
    "min": 16.243,
    "mean": 16.485
   },
   "normal": {
    "duration": 3.71129e+09,
    "iterations": 5.3248e+07,
    "max": 281.57,
    "min": 16.169,
    "mean": 69.6983
   },
   "close-exponents": {
    "duration": 3.70274e+09,
    "iterations": 2.03776e+08,
    "max": 81.474,
    "min": 16.206,
    "mean": 18.1706
   }
  }
---
 sysdeps/i386/fpu/Versions                 |  2 +-
 sysdeps/i386/fpu/e_fmodf.S                | 18 ------------------
 sysdeps/i386/fpu/e_fmodf.c                |  2 ++
 sysdeps/i386/fpu/w_fmodf_compat.c         | 15 ---------------
 sysdeps/ieee754/flt-32/e_fmodf.c          |  5 ++++-
 sysdeps/mach/hurd/i386/libm.abilist       |  1 +
 sysdeps/unix/sysv/linux/i386/libm.abilist |  1 +
 7 files changed, 9 insertions(+), 35 deletions(-)
 delete mode 100644 sysdeps/i386/fpu/e_fmodf.S
 create mode 100644 sysdeps/i386/fpu/e_fmodf.c
 delete mode 100644 sysdeps/i386/fpu/w_fmodf_compat.c

diff --git a/sysdeps/i386/fpu/Versions b/sysdeps/i386/fpu/Versions
index d37bc1eae6..9509f9b7c7 100644
--- a/sysdeps/i386/fpu/Versions
+++ b/sysdeps/i386/fpu/Versions
@@ -5,6 +5,6 @@ libm {
   }
   GLIBC_2.40 {
     # No SVID compatible error handling.
-    fmod;
+    fmod; fmodf;
   }
 }
diff --git a/sysdeps/i386/fpu/e_fmodf.S b/sysdeps/i386/fpu/e_fmodf.S
deleted file mode 100644
index f73ce9da1e..0000000000
--- a/sysdeps/i386/fpu/e_fmodf.S
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Public domain.
- */
-
-#include <machine/asm.h>
-#include <libm-alias-finite.h>
-
-ENTRY(__ieee754_fmodf)
-	flds	8(%esp)
-	flds	4(%esp)
-1:	fprem
-	fstsw	%ax
-	sahf
-	jp	1b
-	fstp	%st(1)
-	ret
-END(__ieee754_fmodf)
-libm_alias_finite (__ieee754_fmodf, __fmodf)
diff --git a/sysdeps/i386/fpu/e_fmodf.c b/sysdeps/i386/fpu/e_fmodf.c
new file mode 100644
index 0000000000..15a0f960bf
--- /dev/null
+++ b/sysdeps/i386/fpu/e_fmodf.c
@@ -0,0 +1,2 @@
+#define FMODF_VERSION GLIBC_2_40
+#include <sysdeps/ieee754/flt-32/e_fmodf.c>
diff --git a/sysdeps/i386/fpu/w_fmodf_compat.c b/sysdeps/i386/fpu/w_fmodf_compat.c
deleted file mode 100644
index 5a61693e51..0000000000
--- a/sysdeps/i386/fpu/w_fmodf_compat.c
+++ /dev/null
@@ -1,15 +0,0 @@
-/* i386 provides an optimized __ieee752_fmodf.  */
-#include <math-svid-compat.h>
-#ifdef SHARED
-# undef SHLIB_COMPAT
-# define SHLIB_COMPAT(a, b, c) 1
-# undef LIBM_SVID_COMPAT
-# define LIBM_SVID_COMPAT 1
-# undef compat_symbol
-# define compat_symbol(a, b, c, d)
-# include <math/w_fmodf_compat.c>
-libm_alias_float (__fmod_compat, fmod)
-#else
-#include <math-type-macros-float.h>
-#include <w_fmod_template.c>
-#endif
diff --git a/sysdeps/ieee754/flt-32/e_fmodf.c b/sysdeps/ieee754/flt-32/e_fmodf.c
index ef95c05800..78071df756 100644
--- a/sysdeps/ieee754/flt-32/e_fmodf.c
+++ b/sysdeps/ieee754/flt-32/e_fmodf.c
@@ -173,7 +173,10 @@ __fmodf (float x, float y)
 }
 strong_alias (__fmodf, __ieee754_fmodf)
 #if LIBM_SVID_COMPAT
-versioned_symbol (libm, __fmodf, fmodf, GLIBC_2_38);
+# ifndef FMODF_VERSION
+#  define FMODF_VERSION GLIBC_2_38
+# endif
+versioned_symbol (libm, __fmodf, fmodf, FMODF_VERSION);
 libm_alias_float_other (__fmod, fmod)
 #else
 libm_alias_float (__fmod, fmod)
diff --git a/sysdeps/mach/hurd/i386/libm.abilist b/sysdeps/mach/hurd/i386/libm.abilist
index 30665f8b1a..88e7538e51 100644
--- a/sysdeps/mach/hurd/i386/libm.abilist
+++ b/sysdeps/mach/hurd/i386/libm.abilist
@@ -1182,3 +1182,4 @@ GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
 GLIBC_2.40 fmod F
+GLIBC_2.40 fmodf F
diff --git a/sysdeps/unix/sysv/linux/i386/libm.abilist b/sysdeps/unix/sysv/linux/i386/libm.abilist
index 44932f111d..c99c60161d 100644
--- a/sysdeps/unix/sysv/linux/i386/libm.abilist
+++ b/sysdeps/unix/sysv/linux/i386/libm.abilist
@@ -1189,3 +1189,4 @@ GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
 GLIBC_2.40 fmod F
+GLIBC_2.40 fmodf F
-- 
2.34.1

[PATCH v2 5/6] math: Fix i386 and m68k exp10 on static build

[Adhemerval Zanella]

The commit 08ddd26814 removed the static exp10 on i386 and
m68k with and empty w_exp10.c (required for the ABIs that uses
the newly implementation).  This patch fixes by adding the
required symbols on the arch-specific w_exp{f}_compat.c
implementation.

Checked on i686-linux-gnu and with a build for m68k-linux-gnu.
---
 math/Makefile                            | 4 +++-
 sysdeps/i386/fpu/w_exp10_compat.c        | 9 +++++++--
 sysdeps/m68k/m680x0/fpu/w_exp10_compat.c | 9 +++++++--
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/math/Makefile b/math/Makefile
index fbb2987248..ad7fd25995 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -367,7 +367,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 	$(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out$* -C $@
 
 
-libm-test-funcs-auto-static =
+libm-test-funcs-auto-static = \
+  exp10 \
+  # libm-test-funcs-auto-static
 libm-test-funcs-noauto-static = \
   fmod \
   # libm-test-funcs-noauto-static
diff --git a/sysdeps/i386/fpu/w_exp10_compat.c b/sysdeps/i386/fpu/w_exp10_compat.c
index b53455386e..49a0e03385 100644
--- a/sysdeps/i386/fpu/w_exp10_compat.c
+++ b/sysdeps/i386/fpu/w_exp10_compat.c
@@ -1,3 +1,8 @@
 /* i386 provides an optimized __ieee754_exp10.  */
-#define NO_COMPAT_NEEDED 1
-#include <math/w_exp10_compat.c>
+#ifdef SHARED
+# define NO_COMPAT_NEEDED 1
+# include <math/w_exp10_compat.c>
+#else
+# include <math-type-macros-double.h>
+# include <w_exp10_template.c>
+#endif
diff --git a/sysdeps/m68k/m680x0/fpu/w_exp10_compat.c b/sysdeps/m68k/m680x0/fpu/w_exp10_compat.c
index 0d3e718626..350f2e4b4d 100644
--- a/sysdeps/m68k/m680x0/fpu/w_exp10_compat.c
+++ b/sysdeps/m68k/m680x0/fpu/w_exp10_compat.c
@@ -1,3 +1,8 @@
 /* m68k provides an optimized __ieee754_exp10.  */
-#define NO_COMPAT_NEEDED 1
-#include <math/w_exp10_compat.c>
+#ifdef SHARED
+# define NO_COMPAT_NEEDED 1
+# include <math/w_exp10_compat.c>
+#else
+# include <math-type-macros-double.h>
+# include <w_exp10_template.c>
+#endif
-- 
2.34.1

[PATCH v2 6/6] i386: Use generic exp10

[Adhemerval Zanella]

The resulting performance is slight better (Ryzen 5900, gcc 13.2.1):

 * master
  "exp10": {
   "": {
    "duration": 3.70091e+09,
    "iterations": 5.8534e+07,
    "max": 91.279,
    "min": 62.6225,
    "mean": 63.2267
   }
  }

 * patch
  "exp10": {
   "": {
    "duration": 3.70793e+09,
    "iterations": 6.328e+07,
    "max": 259.592,
    "min": 52.1145,
    "mean": 58.5957
   }
  }

Checked on i686-linux-gnu.
---
 sysdeps/i386/fpu/Versions                 |  1 +
 sysdeps/i386/fpu/e_exp10.S                | 51 -----------------------
 sysdeps/i386/fpu/e_exp10.c                |  2 +
 sysdeps/i386/fpu/e_exp_data.c             |  1 -
 sysdeps/i386/fpu/w_exp10_compat.c         |  8 ----
 sysdeps/ieee754/dbl-64/e_exp10.c          |  7 +++-
 sysdeps/mach/hurd/i386/libm.abilist       |  1 +
 sysdeps/unix/sysv/linux/i386/libm.abilist |  1 +
 8 files changed, 10 insertions(+), 62 deletions(-)
 delete mode 100644 sysdeps/i386/fpu/e_exp10.S
 create mode 100644 sysdeps/i386/fpu/e_exp10.c
 delete mode 100644 sysdeps/i386/fpu/e_exp_data.c
 delete mode 100644 sysdeps/i386/fpu/w_exp10_compat.c

diff --git a/sysdeps/i386/fpu/Versions b/sysdeps/i386/fpu/Versions
index 9509f9b7c7..7326f25583 100644
--- a/sysdeps/i386/fpu/Versions
+++ b/sysdeps/i386/fpu/Versions
@@ -5,6 +5,7 @@ libm {
   }
   GLIBC_2.40 {
     # No SVID compatible error handling.
+    exp10;
     fmod; fmodf;
   }
 }
diff --git a/sysdeps/i386/fpu/e_exp10.S b/sysdeps/i386/fpu/e_exp10.S
deleted file mode 100644
index 902f70b77f..0000000000
--- a/sysdeps/i386/fpu/e_exp10.S
+++ /dev/null
@@ -1,51 +0,0 @@
-
-#include <machine/asm.h>
-#include <i386-math-asm.h>
-#include <libm-alias-finite.h>
-
-DEFINE_DBL_MIN
-
-#ifdef PIC
-# define MO(op) op##@GOTOFF(%ecx)
-#else
-# define MO(op) op
-#endif
-
-	.text
-/* 10^x = 2^(x * log2(10)) */
-ENTRY(__ieee754_exp10)
-#ifdef  PIC
-	LOAD_PIC_REG (cx)
-#endif
-	fldl	4(%esp)
-/* I added the following ugly construct because exp(+-Inf) resulted
-   in NaN.  The ugliness results from the bright minds at Intel.
-   For the i686 the code can be written better.
-   -- drepper@cygnus.com.  */
-	fxam				/* Is NaN or +-Inf?  */
-	fstsw	%ax
-	movb	$0x45, %dh
-	andb	%ah, %dh
-	cmpb	$0x05, %dh
-	je	1f			/* Is +-Inf, jump.  */
-	fldl2t
-	fmulp				/* x * log2(10) */
-	fld	%st
-	frndint				/* int(x * log2(10)) */
-	fsubr	%st,%st(1)		/* fract(x * log2(10)) */
-	fxch
-	f2xm1				/* 2^(fract(x * log2(10))) - 1 */
-	fld1
-	faddp				/* 2^(fract(x * log2(10))) */
-	fscale				/* e^x */
-	fstp	%st(1)
-	DBL_NARROW_EVAL_UFLOW_NONNEG_NAN
-	ret
-
-1:	testl	$0x200, %eax		/* Test sign.  */
-	jz	2f			/* If positive, jump.  */
-	fstp	%st
-	fldz				/* Set result to 0.  */
-2:	ret
-END (__ieee754_exp10)
-libm_alias_finite (__ieee754_exp10, __exp10)
diff --git a/sysdeps/i386/fpu/e_exp10.c b/sysdeps/i386/fpu/e_exp10.c
new file mode 100644
index 0000000000..340254fc6e
--- /dev/null
+++ b/sysdeps/i386/fpu/e_exp10.c
@@ -0,0 +1,2 @@
+#define EXP10_VERSION GLIBC_2_40
+#include <sysdeps/ieee754/dbl-64/e_exp10.c>
diff --git a/sysdeps/i386/fpu/e_exp_data.c b/sysdeps/i386/fpu/e_exp_data.c
deleted file mode 100644
index 1cc8931700..0000000000
--- a/sysdeps/i386/fpu/e_exp_data.c
+++ /dev/null
@@ -1 +0,0 @@
-/* Not needed.  */
diff --git a/sysdeps/i386/fpu/w_exp10_compat.c b/sysdeps/i386/fpu/w_exp10_compat.c
deleted file mode 100644
index 49a0e03385..0000000000
--- a/sysdeps/i386/fpu/w_exp10_compat.c
+++ /dev/null
@@ -1,8 +0,0 @@
-/* i386 provides an optimized __ieee754_exp10.  */
-#ifdef SHARED
-# define NO_COMPAT_NEEDED 1
-# include <math/w_exp10_compat.c>
-#else
-# include <math-type-macros-double.h>
-# include <w_exp10_template.c>
-#endif
diff --git a/sysdeps/ieee754/dbl-64/e_exp10.c b/sysdeps/ieee754/dbl-64/e_exp10.c
index 225fc74c4c..c63b852f72 100644
--- a/sysdeps/ieee754/dbl-64/e_exp10.c
+++ b/sysdeps/ieee754/dbl-64/e_exp10.c
@@ -99,7 +99,7 @@ __exp10 (double x)
 
   /* Reduce x: z = x * N / log10(2), k = round(z).  */
   double_t z = __exp_data.invlog10_2N * x;
-  double_t kd;
+  double kd;
   int64_t ki;
 #if TOINT_INTRINSICS
   kd = roundtoint (z);
@@ -147,7 +147,10 @@ __exp10 (double x)
 strong_alias (__exp10, __ieee754_exp10)
 libm_alias_finite (__ieee754_exp10, __exp10)
 #if LIBM_SVID_COMPAT
-versioned_symbol (libm, __exp10, exp10, GLIBC_2_39);
+# ifndef EXP10_VERSION
+#  define EXP10_VERSION GLIBC_2_39
+# endif
+versioned_symbol (libm, __exp10, exp10, EXP10_VERSION);
 libm_alias_double_other (__exp10, exp10)
 #else
 libm_alias_double (__exp10, exp10)
diff --git a/sysdeps/mach/hurd/i386/libm.abilist b/sysdeps/mach/hurd/i386/libm.abilist
index 88e7538e51..01c5633663 100644
--- a/sysdeps/mach/hurd/i386/libm.abilist
+++ b/sysdeps/mach/hurd/i386/libm.abilist
@@ -1181,5 +1181,6 @@ GLIBC_2.35 fsqrt F
 GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
+GLIBC_2.40 exp10 F
 GLIBC_2.40 fmod F
 GLIBC_2.40 fmodf F
diff --git a/sysdeps/unix/sysv/linux/i386/libm.abilist b/sysdeps/unix/sysv/linux/i386/libm.abilist
index c99c60161d..3413cfdbe7 100644
--- a/sysdeps/unix/sysv/linux/i386/libm.abilist
+++ b/sysdeps/unix/sysv/linux/i386/libm.abilist
@@ -1188,5 +1188,6 @@ GLIBC_2.35 fsqrt F
 GLIBC_2.35 fsqrtl F
 GLIBC_2.35 hypot F
 GLIBC_2.35 hypotf F
+GLIBC_2.40 exp10 F
 GLIBC_2.40 fmod F
 GLIBC_2.40 fmodf F
-- 
2.34.1

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Joseph Myers]

On Thu, 21 Mar 2024, Adhemerval Zanella wrote:

> It basically copy the already in place rules for dynamic tests
> for auto-generated math tests for all support types.  To avoid
> the need to duplicate .inc files, a .SECONDEXPANSION rules is
> adeed for the gen-libm-test.py generation.

Running the autogenerated tests seems overly complicated when the goal is 
simply to verify that linking a call succeeds.

-- 
Joseph S. Myers
josmyers@redhat.com

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Florian Weimer]

* Joseph Myers:

> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>
>> It basically copy the already in place rules for dynamic tests
>> for auto-generated math tests for all support types.  To avoid
>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>> adeed for the gen-libm-test.py generation.
>
> Running the autogenerated tests seems overly complicated when the goal is 
> simply to verify that linking a call succeeds.

Right.  And I would prefer if we could mark compat/otherwise non-static
symbols in the ABI lists and use those for testing static linking.

Thanks,
Florian

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 22/03/24 03:46, Florian Weimer wrote:
> * Joseph Myers:
> 
>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>
>>> It basically copy the already in place rules for dynamic tests
>>> for auto-generated math tests for all support types.  To avoid
>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>> adeed for the gen-libm-test.py generation.
>>
>> Running the autogenerated tests seems overly complicated when the goal is 
>> simply to verify that linking a call succeeds.
> 
> Right.  And I would prefer if we could mark compat/otherwise non-static
> symbols in the ABI lists and use those for testing static linking.
> 

That was my first approach, but then as an experiment I enabled static
build for most of math tests and unexpectedly it has shows some failures
on x86_64:

FAIL: math/test-float64x-acos
FAIL: math/test-float64x-log10
FAIL: math/test-float64x-log2
FAIL: math/test-float64x-y0
FAIL: math/test-float64x-y1
FAIL: math/test-ldouble-acos
FAIL: math/test-ldouble-log10
FAIL: math/test-ldouble-log2
FAIL: math/test-ldouble-y0
FAIL: math/test-ldouble-y1

$ cat math/test-float64x-acos.out
testing _Float64x (without inline functions)
Failure: acos (max_value): Exception "Overflow" set
Failure: acos (-max_value): Exception "Overflow" set
Failure: acos_downward (max_value): Exception "Overflow" set
Failure: acos_downward (-max_value): Exception "Overflow" set
Failure: acos_towardzero (max_value): Exception "Overflow" set
Failure: acos_towardzero (-max_value): Exception "Overflow" set
Failure: acos_upward (max_value): Exception "Overflow" set
Failure: acos_upward (-max_value): Exception "Overflow" set

My plan was to eventually track down what might be happening here, and
the currently autogenerated tests gave me a nice scaffolding to add coverage
tests.

I can add simple linking tests for this specific failure, and I also think
that reword all the static ABI check for this issues in a bit too much
for this patchset.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Florian Weimer]

* Adhemerval Zanella Netto:

> On 22/03/24 03:46, Florian Weimer wrote:
>> * Joseph Myers:
>> 
>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>>
>>>> It basically copy the already in place rules for dynamic tests
>>>> for auto-generated math tests for all support types.  To avoid
>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>>> adeed for the gen-libm-test.py generation.
>>>
>>> Running the autogenerated tests seems overly complicated when the goal is 
>>> simply to verify that linking a call succeeds.
>> 
>> Right.  And I would prefer if we could mark compat/otherwise non-static
>> symbols in the ABI lists and use those for testing static linking.
>> 
>
> That was my first approach, but then as an experiment I enabled static
> build for most of math tests and unexpectedly it has shows some failures
> on x86_64:
>
> FAIL: math/test-float64x-acos
> FAIL: math/test-float64x-log10
> FAIL: math/test-float64x-log2
> FAIL: math/test-float64x-y0
> FAIL: math/test-float64x-y1
> FAIL: math/test-ldouble-acos
> FAIL: math/test-ldouble-log10
> FAIL: math/test-ldouble-log2
> FAIL: math/test-ldouble-y0
> FAIL: math/test-ldouble-y1
>
> $ cat math/test-float64x-acos.out
> testing _Float64x (without inline functions)
> Failure: acos (max_value): Exception "Overflow" set
> Failure: acos (-max_value): Exception "Overflow" set
> Failure: acos_downward (max_value): Exception "Overflow" set
> Failure: acos_downward (-max_value): Exception "Overflow" set
> Failure: acos_towardzero (max_value): Exception "Overflow" set
> Failure: acos_towardzero (-max_value): Exception "Overflow" set
> Failure: acos_upward (max_value): Exception "Overflow" set
> Failure: acos_upward (-max_value): Exception "Overflow" set
>
> My plan was to eventually track down what might be happening here, and
> the currently autogenerated tests gave me a nice scaffolding to add coverage
> tests.

Interesting.  On the other hand, getting --disable-shared to work and
just run the *entire* test suite could provide value, too.  The last
time we discussed this we weren't sure if we had static-specific
failures, but your example shows that we do.

Thanks,
Florian

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 22/03/24 12:51, Florian Weimer wrote:
> * Adhemerval Zanella Netto:
> 
>> On 22/03/24 03:46, Florian Weimer wrote:
>>> * Joseph Myers:
>>>
>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>>>
>>>>> It basically copy the already in place rules for dynamic tests
>>>>> for auto-generated math tests for all support types.  To avoid
>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>>>> adeed for the gen-libm-test.py generation.
>>>>
>>>> Running the autogenerated tests seems overly complicated when the goal is 
>>>> simply to verify that linking a call succeeds.
>>>
>>> Right.  And I would prefer if we could mark compat/otherwise non-static
>>> symbols in the ABI lists and use those for testing static linking.
>>>
>>
>> That was my first approach, but then as an experiment I enabled static
>> build for most of math tests and unexpectedly it has shows some failures
>> on x86_64:
>>
>> FAIL: math/test-float64x-acos
>> FAIL: math/test-float64x-log10
>> FAIL: math/test-float64x-log2
>> FAIL: math/test-float64x-y0
>> FAIL: math/test-float64x-y1
>> FAIL: math/test-ldouble-acos
>> FAIL: math/test-ldouble-log10
>> FAIL: math/test-ldouble-log2
>> FAIL: math/test-ldouble-y0
>> FAIL: math/test-ldouble-y1
>>
>> $ cat math/test-float64x-acos.out
>> testing _Float64x (without inline functions)
>> Failure: acos (max_value): Exception "Overflow" set
>> Failure: acos (-max_value): Exception "Overflow" set
>> Failure: acos_downward (max_value): Exception "Overflow" set
>> Failure: acos_downward (-max_value): Exception "Overflow" set
>> Failure: acos_towardzero (max_value): Exception "Overflow" set
>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
>> Failure: acos_upward (max_value): Exception "Overflow" set
>> Failure: acos_upward (-max_value): Exception "Overflow" set
>>
>> My plan was to eventually track down what might be happening here, and
>> the currently autogenerated tests gave me a nice scaffolding to add coverage
>> tests.
> 
> Interesting.  On the other hand, getting --disable-shared to work and
> just run the *entire* test suite could provide value, too.  The last
> time we discussed this we weren't sure if we had static-specific
> failures, but your example shows that we do.
> 

The main problem imho is --disable-shared is essentially a maintainer 
option. Although some installed programs will be static linked, it is
really useful on checking if static linking is really working as expected.

And it also requires *another* build and check iteration, which duplicates
the work required in most cases (since static libraries are still built
on default for --enable-shared).  I tried to help a coworker on support the
--disable-shared and I recall another potential issues was the resulting
disk usage (and thus build requirements) was quite high due glibc poor
organization on static build requirements.  

There also another complication where we will need to constantly add 
$(build-shared) and duplicate the CI work to ensure both configure
builds are ok.

So I really think we should phase-out --disable-shared and work towards
on add more static build tests.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[H.J. Lu]

On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 22/03/24 12:51, Florian Weimer wrote:
> > * Adhemerval Zanella Netto:
> >
> >> On 22/03/24 03:46, Florian Weimer wrote:
> >>> * Joseph Myers:
> >>>
> >>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
> >>>>
> >>>>> It basically copy the already in place rules for dynamic tests
> >>>>> for auto-generated math tests for all support types.  To avoid
> >>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
> >>>>> adeed for the gen-libm-test.py generation.
> >>>>
> >>>> Running the autogenerated tests seems overly complicated when the goal is
> >>>> simply to verify that linking a call succeeds.
> >>>
> >>> Right.  And I would prefer if we could mark compat/otherwise non-static
> >>> symbols in the ABI lists and use those for testing static linking.
> >>>
> >>
> >> That was my first approach, but then as an experiment I enabled static
> >> build for most of math tests and unexpectedly it has shows some failures
> >> on x86_64:
> >>
> >> FAIL: math/test-float64x-acos
> >> FAIL: math/test-float64x-log10
> >> FAIL: math/test-float64x-log2
> >> FAIL: math/test-float64x-y0
> >> FAIL: math/test-float64x-y1
> >> FAIL: math/test-ldouble-acos
> >> FAIL: math/test-ldouble-log10
> >> FAIL: math/test-ldouble-log2
> >> FAIL: math/test-ldouble-y0
> >> FAIL: math/test-ldouble-y1
> >>
> >> $ cat math/test-float64x-acos.out
> >> testing _Float64x (without inline functions)
> >> Failure: acos (max_value): Exception "Overflow" set
> >> Failure: acos (-max_value): Exception "Overflow" set
> >> Failure: acos_downward (max_value): Exception "Overflow" set
> >> Failure: acos_downward (-max_value): Exception "Overflow" set
> >> Failure: acos_towardzero (max_value): Exception "Overflow" set
> >> Failure: acos_towardzero (-max_value): Exception "Overflow" set
> >> Failure: acos_upward (max_value): Exception "Overflow" set
> >> Failure: acos_upward (-max_value): Exception "Overflow" set
> >>

This new static test only checks link failure.  It doesn't check if the static
implementation is correct.  We may not have more functional coverage
for static libm in the first static libm test patch.  But the first new static
libm tests should least expose one static libm failure on x86-64.

> >> My plan was to eventually track down what might be happening here, and
> >> the currently autogenerated tests gave me a nice scaffolding to add coverage
> >> tests.
> >
> > Interesting.  On the other hand, getting --disable-shared to work and
> > just run the *entire* test suite could provide value, too.  The last
> > time we discussed this we weren't sure if we had static-specific
> > failures, but your example shows that we do.
> >
>
> The main problem imho is --disable-shared is essentially a maintainer
> option. Although some installed programs will be static linked, it is
> really useful on checking if static linking is really working as expected.
>
> And it also requires *another* build and check iteration, which duplicates
> the work required in most cases (since static libraries are still built
> on default for --enable-shared).  I tried to help a coworker on support the
> --disable-shared and I recall another potential issues was the resulting
> disk usage (and thus build requirements) was quite high due glibc poor
> organization on static build requirements.
>
> There also another complication where we will need to constantly add
> $(build-shared) and duplicate the CI work to ensure both configure
> builds are ok.
>
> So I really think we should phase-out --disable-shared and work towards
> on add more static build tests.

Agreed.  We should add one static libm functional test to each libm
functional test.  With this, the static libm link tests won't be needed.

-- 
H.J.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 25/03/24 10:34, H.J. Lu wrote:
> On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 22/03/24 12:51, Florian Weimer wrote:
>>> * Adhemerval Zanella Netto:
>>>
>>>> On 22/03/24 03:46, Florian Weimer wrote:
>>>>> * Joseph Myers:
>>>>>
>>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>>>>>
>>>>>>> It basically copy the already in place rules for dynamic tests
>>>>>>> for auto-generated math tests for all support types.  To avoid
>>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>>>>>> adeed for the gen-libm-test.py generation.
>>>>>>
>>>>>> Running the autogenerated tests seems overly complicated when the goal is
>>>>>> simply to verify that linking a call succeeds.
>>>>>
>>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
>>>>> symbols in the ABI lists and use those for testing static linking.
>>>>>
>>>>
>>>> That was my first approach, but then as an experiment I enabled static
>>>> build for most of math tests and unexpectedly it has shows some failures
>>>> on x86_64:
>>>>
>>>> FAIL: math/test-float64x-acos
>>>> FAIL: math/test-float64x-log10
>>>> FAIL: math/test-float64x-log2
>>>> FAIL: math/test-float64x-y0
>>>> FAIL: math/test-float64x-y1
>>>> FAIL: math/test-ldouble-acos
>>>> FAIL: math/test-ldouble-log10
>>>> FAIL: math/test-ldouble-log2
>>>> FAIL: math/test-ldouble-y0
>>>> FAIL: math/test-ldouble-y1
>>>>
>>>> $ cat math/test-float64x-acos.out
>>>> testing _Float64x (without inline functions)
>>>> Failure: acos (max_value): Exception "Overflow" set
>>>> Failure: acos (-max_value): Exception "Overflow" set
>>>> Failure: acos_downward (max_value): Exception "Overflow" set
>>>> Failure: acos_downward (-max_value): Exception "Overflow" set
>>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
>>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
>>>> Failure: acos_upward (max_value): Exception "Overflow" set
>>>> Failure: acos_upward (-max_value): Exception "Overflow" set
>>>>
> 
> This new static test only checks link failure.  It doesn't check if the static
> implementation is correct.  We may not have more functional coverage
> for static libm in the first static libm test patch.  But the first new static
> libm tests should least expose one static libm failure on x86-64.

The first patch is just a framework so we can selective add new static
tests, I haven't hook all of the autogenerated tests because this would
add more cpu and disk usage.

And the test added on libm-test-funcs-*-static rules does check for
the implementation, using the default math skeleton test (including
ulp, rounding, exceptions, etc).

> 
>>>> My plan was to eventually track down what might be happening here, and
>>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
>>>> tests.
>>>
>>> Interesting.  On the other hand, getting --disable-shared to work and
>>> just run the *entire* test suite could provide value, too.  The last
>>> time we discussed this we weren't sure if we had static-specific
>>> failures, but your example shows that we do.
>>>
>>
>> The main problem imho is --disable-shared is essentially a maintainer
>> option. Although some installed programs will be static linked, it is
>> really useful on checking if static linking is really working as expected.
>>
>> And it also requires *another* build and check iteration, which duplicates
>> the work required in most cases (since static libraries are still built
>> on default for --enable-shared).  I tried to help a coworker on support the
>> --disable-shared and I recall another potential issues was the resulting
>> disk usage (and thus build requirements) was quite high due glibc poor
>> organization on static build requirements.
>>
>> There also another complication where we will need to constantly add
>> $(build-shared) and duplicate the CI work to ensure both configure
>> builds are ok.
>>
>> So I really think we should phase-out --disable-shared and work towards
>> on add more static build tests.
> 
> Agreed.  We should add one static libm functional test to each libm
> functional test.  With this, the static libm link tests won't be needed.

For this patchset only added the required one to check for symbols that
there were some regression with recent fixes. But it should be doable to
hook all tests for all symbols, although it would require some more Makefile 
rules to hook the tgmath ones.
  
I don't have a strong opinion in fact, and I am ok on changing to Joseph's
suggestion to check minimal tests to check for static linking support.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[H.J. Lu]

On Mon, Mar 25, 2024 at 7:13 AM Adhemerval Zanella Netto
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 25/03/24 10:34, H.J. Lu wrote:
> > On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 22/03/24 12:51, Florian Weimer wrote:
> >>> * Adhemerval Zanella Netto:
> >>>
> >>>> On 22/03/24 03:46, Florian Weimer wrote:
> >>>>> * Joseph Myers:
> >>>>>
> >>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
> >>>>>>
> >>>>>>> It basically copy the already in place rules for dynamic tests
> >>>>>>> for auto-generated math tests for all support types.  To avoid
> >>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
> >>>>>>> adeed for the gen-libm-test.py generation.
> >>>>>>
> >>>>>> Running the autogenerated tests seems overly complicated when the goal is
> >>>>>> simply to verify that linking a call succeeds.
> >>>>>
> >>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
> >>>>> symbols in the ABI lists and use those for testing static linking.
> >>>>>
> >>>>
> >>>> That was my first approach, but then as an experiment I enabled static
> >>>> build for most of math tests and unexpectedly it has shows some failures
> >>>> on x86_64:
> >>>>
> >>>> FAIL: math/test-float64x-acos
> >>>> FAIL: math/test-float64x-log10
> >>>> FAIL: math/test-float64x-log2
> >>>> FAIL: math/test-float64x-y0
> >>>> FAIL: math/test-float64x-y1
> >>>> FAIL: math/test-ldouble-acos
> >>>> FAIL: math/test-ldouble-log10
> >>>> FAIL: math/test-ldouble-log2
> >>>> FAIL: math/test-ldouble-y0
> >>>> FAIL: math/test-ldouble-y1
> >>>>
> >>>> $ cat math/test-float64x-acos.out
> >>>> testing _Float64x (without inline functions)
> >>>> Failure: acos (max_value): Exception "Overflow" set
> >>>> Failure: acos (-max_value): Exception "Overflow" set
> >>>> Failure: acos_downward (max_value): Exception "Overflow" set
> >>>> Failure: acos_downward (-max_value): Exception "Overflow" set
> >>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
> >>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
> >>>> Failure: acos_upward (max_value): Exception "Overflow" set
> >>>> Failure: acos_upward (-max_value): Exception "Overflow" set
> >>>>
> >
> > This new static test only checks link failure.  It doesn't check if the static
> > implementation is correct.  We may not have more functional coverage
> > for static libm in the first static libm test patch.  But the first new static
> > libm tests should least expose one static libm failure on x86-64.
>
> The first patch is just a framework so we can selective add new static
> tests, I haven't hook all of the autogenerated tests because this would
> add more cpu and disk usage.
>
> And the test added on libm-test-funcs-*-static rules does check for
> the implementation, using the default math skeleton test (including
> ulp, rounding, exceptions, etc).
>
> >
> >>>> My plan was to eventually track down what might be happening here, and
> >>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
> >>>> tests.
> >>>
> >>> Interesting.  On the other hand, getting --disable-shared to work and
> >>> just run the *entire* test suite could provide value, too.  The last
> >>> time we discussed this we weren't sure if we had static-specific
> >>> failures, but your example shows that we do.
> >>>
> >>
> >> The main problem imho is --disable-shared is essentially a maintainer
> >> option. Although some installed programs will be static linked, it is
> >> really useful on checking if static linking is really working as expected.
> >>
> >> And it also requires *another* build and check iteration, which duplicates
> >> the work required in most cases (since static libraries are still built
> >> on default for --enable-shared).  I tried to help a coworker on support the
> >> --disable-shared and I recall another potential issues was the resulting
> >> disk usage (and thus build requirements) was quite high due glibc poor
> >> organization on static build requirements.
> >>
> >> There also another complication where we will need to constantly add
> >> $(build-shared) and duplicate the CI work to ensure both configure
> >> builds are ok.
> >>
> >> So I really think we should phase-out --disable-shared and work towards
> >> on add more static build tests.
> >
> > Agreed.  We should add one static libm functional test to each libm
> > functional test.  With this, the static libm link tests won't be needed.
>
> For this patchset only added the required one to check for symbols that
> there were some regression with recent fixes. But it should be doable to
> hook all tests for all symbols, although it would require some more Makefile
> rules to hook the tgmath ones.

The first patch should just add the functional tests for the missing static
libm functions with Makefile changes which can be extended to cover
other libm functions.

> I don't have a strong opinion in fact, and I am ok on changing to Joseph's
> suggestion to check minimal tests to check for static linking support.



-- 
H.J.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 25/03/24 11:25, H.J. Lu wrote:
> On Mon, Mar 25, 2024 at 7:13 AM Adhemerval Zanella Netto
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 25/03/24 10:34, H.J. Lu wrote:
>>> On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
>>> <adhemerval.zanella@linaro.org> wrote:
>>>>
>>>>
>>>>
>>>> On 22/03/24 12:51, Florian Weimer wrote:
>>>>> * Adhemerval Zanella Netto:
>>>>>
>>>>>> On 22/03/24 03:46, Florian Weimer wrote:
>>>>>>> * Joseph Myers:
>>>>>>>
>>>>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>>>>>>>
>>>>>>>>> It basically copy the already in place rules for dynamic tests
>>>>>>>>> for auto-generated math tests for all support types.  To avoid
>>>>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>>>>>>>> adeed for the gen-libm-test.py generation.
>>>>>>>>
>>>>>>>> Running the autogenerated tests seems overly complicated when the goal is
>>>>>>>> simply to verify that linking a call succeeds.
>>>>>>>
>>>>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
>>>>>>> symbols in the ABI lists and use those for testing static linking.
>>>>>>>
>>>>>>
>>>>>> That was my first approach, but then as an experiment I enabled static
>>>>>> build for most of math tests and unexpectedly it has shows some failures
>>>>>> on x86_64:
>>>>>>
>>>>>> FAIL: math/test-float64x-acos
>>>>>> FAIL: math/test-float64x-log10
>>>>>> FAIL: math/test-float64x-log2
>>>>>> FAIL: math/test-float64x-y0
>>>>>> FAIL: math/test-float64x-y1
>>>>>> FAIL: math/test-ldouble-acos
>>>>>> FAIL: math/test-ldouble-log10
>>>>>> FAIL: math/test-ldouble-log2
>>>>>> FAIL: math/test-ldouble-y0
>>>>>> FAIL: math/test-ldouble-y1
>>>>>>
>>>>>> $ cat math/test-float64x-acos.out
>>>>>> testing _Float64x (without inline functions)
>>>>>> Failure: acos (max_value): Exception "Overflow" set
>>>>>> Failure: acos (-max_value): Exception "Overflow" set
>>>>>> Failure: acos_downward (max_value): Exception "Overflow" set
>>>>>> Failure: acos_downward (-max_value): Exception "Overflow" set
>>>>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
>>>>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
>>>>>> Failure: acos_upward (max_value): Exception "Overflow" set
>>>>>> Failure: acos_upward (-max_value): Exception "Overflow" set
>>>>>>
>>>
>>> This new static test only checks link failure.  It doesn't check if the static
>>> implementation is correct.  We may not have more functional coverage
>>> for static libm in the first static libm test patch.  But the first new static
>>> libm tests should least expose one static libm failure on x86-64.
>>
>> The first patch is just a framework so we can selective add new static
>> tests, I haven't hook all of the autogenerated tests because this would
>> add more cpu and disk usage.
>>
>> And the test added on libm-test-funcs-*-static rules does check for
>> the implementation, using the default math skeleton test (including
>> ulp, rounding, exceptions, etc).
>>
>>>
>>>>>> My plan was to eventually track down what might be happening here, and
>>>>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
>>>>>> tests.
>>>>>
>>>>> Interesting.  On the other hand, getting --disable-shared to work and
>>>>> just run the *entire* test suite could provide value, too.  The last
>>>>> time we discussed this we weren't sure if we had static-specific
>>>>> failures, but your example shows that we do.
>>>>>
>>>>
>>>> The main problem imho is --disable-shared is essentially a maintainer
>>>> option. Although some installed programs will be static linked, it is
>>>> really useful on checking if static linking is really working as expected.
>>>>
>>>> And it also requires *another* build and check iteration, which duplicates
>>>> the work required in most cases (since static libraries are still built
>>>> on default for --enable-shared).  I tried to help a coworker on support the
>>>> --disable-shared and I recall another potential issues was the resulting
>>>> disk usage (and thus build requirements) was quite high due glibc poor
>>>> organization on static build requirements.
>>>>
>>>> There also another complication where we will need to constantly add
>>>> $(build-shared) and duplicate the CI work to ensure both configure
>>>> builds are ok.
>>>>
>>>> So I really think we should phase-out --disable-shared and work towards
>>>> on add more static build tests.
>>>
>>> Agreed.  We should add one static libm functional test to each libm
>>> functional test.  With this, the static libm link tests won't be needed.
>>
>> For this patchset only added the required one to check for symbols that
>> there were some regression with recent fixes. But it should be doable to
>> hook all tests for all symbols, although it would require some more Makefile
>> rules to hook the tgmath ones.
> 
> The first patch should just add the functional tests for the missing static
> libm functions with Makefile changes which can be extended to cover
> other libm functions.
> 

And it does on second patch exactly as you suggested:

diff --git a/math/Makefile b/math/Makefile
index aef9cec1a1..fbb2987248 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -368,7 +368,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 
 
 libm-test-funcs-auto-static =
-libm-test-funcs-noauto-static =
+libm-test-funcs-noauto-static = \
+  fmod \
+  # libm-test-funcs-noauto-static
 libm-test-funcs-compat-static =
 libm-test-funcs-narrow-static =
 libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)


If you check the build directory, it will have a test-<type>-fmod-static
that would fail to build without the rest of the patch.

>> I don't have a strong opinion in fact, and I am ok on changing to Joseph's
>> suggestion to check minimal tests to check for static linking support.
> 
> 
> 

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[H.J. Lu]

On Mon, Mar 25, 2024 at 7:29 AM Adhemerval Zanella Netto
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 25/03/24 11:25, H.J. Lu wrote:
> > On Mon, Mar 25, 2024 at 7:13 AM Adhemerval Zanella Netto
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 25/03/24 10:34, H.J. Lu wrote:
> >>> On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
> >>> <adhemerval.zanella@linaro.org> wrote:
> >>>>
> >>>>
> >>>>
> >>>> On 22/03/24 12:51, Florian Weimer wrote:
> >>>>> * Adhemerval Zanella Netto:
> >>>>>
> >>>>>> On 22/03/24 03:46, Florian Weimer wrote:
> >>>>>>> * Joseph Myers:
> >>>>>>>
> >>>>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
> >>>>>>>>
> >>>>>>>>> It basically copy the already in place rules for dynamic tests
> >>>>>>>>> for auto-generated math tests for all support types.  To avoid
> >>>>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
> >>>>>>>>> adeed for the gen-libm-test.py generation.
> >>>>>>>>
> >>>>>>>> Running the autogenerated tests seems overly complicated when the goal is
> >>>>>>>> simply to verify that linking a call succeeds.
> >>>>>>>
> >>>>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
> >>>>>>> symbols in the ABI lists and use those for testing static linking.
> >>>>>>>
> >>>>>>
> >>>>>> That was my first approach, but then as an experiment I enabled static
> >>>>>> build for most of math tests and unexpectedly it has shows some failures
> >>>>>> on x86_64:
> >>>>>>
> >>>>>> FAIL: math/test-float64x-acos
> >>>>>> FAIL: math/test-float64x-log10
> >>>>>> FAIL: math/test-float64x-log2
> >>>>>> FAIL: math/test-float64x-y0
> >>>>>> FAIL: math/test-float64x-y1
> >>>>>> FAIL: math/test-ldouble-acos
> >>>>>> FAIL: math/test-ldouble-log10
> >>>>>> FAIL: math/test-ldouble-log2
> >>>>>> FAIL: math/test-ldouble-y0
> >>>>>> FAIL: math/test-ldouble-y1
> >>>>>>
> >>>>>> $ cat math/test-float64x-acos.out
> >>>>>> testing _Float64x (without inline functions)
> >>>>>> Failure: acos (max_value): Exception "Overflow" set
> >>>>>> Failure: acos (-max_value): Exception "Overflow" set
> >>>>>> Failure: acos_downward (max_value): Exception "Overflow" set
> >>>>>> Failure: acos_downward (-max_value): Exception "Overflow" set
> >>>>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
> >>>>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
> >>>>>> Failure: acos_upward (max_value): Exception "Overflow" set
> >>>>>> Failure: acos_upward (-max_value): Exception "Overflow" set
> >>>>>>
> >>>
> >>> This new static test only checks link failure.  It doesn't check if the static
> >>> implementation is correct.  We may not have more functional coverage
> >>> for static libm in the first static libm test patch.  But the first new static
> >>> libm tests should least expose one static libm failure on x86-64.
> >>
> >> The first patch is just a framework so we can selective add new static
> >> tests, I haven't hook all of the autogenerated tests because this would
> >> add more cpu and disk usage.
> >>
> >> And the test added on libm-test-funcs-*-static rules does check for
> >> the implementation, using the default math skeleton test (including
> >> ulp, rounding, exceptions, etc).
> >>
> >>>
> >>>>>> My plan was to eventually track down what might be happening here, and
> >>>>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
> >>>>>> tests.
> >>>>>
> >>>>> Interesting.  On the other hand, getting --disable-shared to work and
> >>>>> just run the *entire* test suite could provide value, too.  The last
> >>>>> time we discussed this we weren't sure if we had static-specific
> >>>>> failures, but your example shows that we do.
> >>>>>
> >>>>
> >>>> The main problem imho is --disable-shared is essentially a maintainer
> >>>> option. Although some installed programs will be static linked, it is
> >>>> really useful on checking if static linking is really working as expected.
> >>>>
> >>>> And it also requires *another* build and check iteration, which duplicates
> >>>> the work required in most cases (since static libraries are still built
> >>>> on default for --enable-shared).  I tried to help a coworker on support the
> >>>> --disable-shared and I recall another potential issues was the resulting
> >>>> disk usage (and thus build requirements) was quite high due glibc poor
> >>>> organization on static build requirements.
> >>>>
> >>>> There also another complication where we will need to constantly add
> >>>> $(build-shared) and duplicate the CI work to ensure both configure
> >>>> builds are ok.
> >>>>
> >>>> So I really think we should phase-out --disable-shared and work towards
> >>>> on add more static build tests.
> >>>
> >>> Agreed.  We should add one static libm functional test to each libm
> >>> functional test.  With this, the static libm link tests won't be needed.
> >>
> >> For this patchset only added the required one to check for symbols that
> >> there were some regression with recent fixes. But it should be doable to
> >> hook all tests for all symbols, although it would require some more Makefile
> >> rules to hook the tgmath ones.
> >
> > The first patch should just add the functional tests for the missing static
> > libm functions with Makefile changes which can be extended to cover
> > other libm functions.
> >
>
> And it does on second patch exactly as you suggested:
>
> diff --git a/math/Makefile b/math/Makefile
> index aef9cec1a1..fbb2987248 100644
> --- a/math/Makefile
> +++ b/math/Makefile
> @@ -368,7 +368,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
>
>
>  libm-test-funcs-auto-static =
> -libm-test-funcs-noauto-static =
> +libm-test-funcs-noauto-static = \
> +  fmod \
> +  # libm-test-funcs-noauto-static
>  libm-test-funcs-compat-static =
>  libm-test-funcs-narrow-static =
>  libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
>
>
> If you check the build directory, it will have a test-<type>-fmod-static
> that would fail to build without the rest of the patch.
>

We already generate libm tests under math:

math/cabs.c
math/cabsf128.c
math/cabsf.c
math/cabsl.c
...

Can we also generate

math/cabs-static.c
...

and add them to libm tests?

-- 
H.J.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 25/03/24 11:52, H.J. Lu wrote:
> On Mon, Mar 25, 2024 at 7:29 AM Adhemerval Zanella Netto
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 25/03/24 11:25, H.J. Lu wrote:
>>> On Mon, Mar 25, 2024 at 7:13 AM Adhemerval Zanella Netto
>>> <adhemerval.zanella@linaro.org> wrote:
>>>>
>>>>
>>>>
>>>> On 25/03/24 10:34, H.J. Lu wrote:
>>>>> On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
>>>>> <adhemerval.zanella@linaro.org> wrote:
>>>>>>
>>>>>>
>>>>>>
>>>>>> On 22/03/24 12:51, Florian Weimer wrote:
>>>>>>> * Adhemerval Zanella Netto:
>>>>>>>
>>>>>>>> On 22/03/24 03:46, Florian Weimer wrote:
>>>>>>>>> * Joseph Myers:
>>>>>>>>>
>>>>>>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
>>>>>>>>>>
>>>>>>>>>>> It basically copy the already in place rules for dynamic tests
>>>>>>>>>>> for auto-generated math tests for all support types.  To avoid
>>>>>>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
>>>>>>>>>>> adeed for the gen-libm-test.py generation.
>>>>>>>>>>
>>>>>>>>>> Running the autogenerated tests seems overly complicated when the goal is
>>>>>>>>>> simply to verify that linking a call succeeds.
>>>>>>>>>
>>>>>>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
>>>>>>>>> symbols in the ABI lists and use those for testing static linking.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That was my first approach, but then as an experiment I enabled static
>>>>>>>> build for most of math tests and unexpectedly it has shows some failures
>>>>>>>> on x86_64:
>>>>>>>>
>>>>>>>> FAIL: math/test-float64x-acos
>>>>>>>> FAIL: math/test-float64x-log10
>>>>>>>> FAIL: math/test-float64x-log2
>>>>>>>> FAIL: math/test-float64x-y0
>>>>>>>> FAIL: math/test-float64x-y1
>>>>>>>> FAIL: math/test-ldouble-acos
>>>>>>>> FAIL: math/test-ldouble-log10
>>>>>>>> FAIL: math/test-ldouble-log2
>>>>>>>> FAIL: math/test-ldouble-y0
>>>>>>>> FAIL: math/test-ldouble-y1
>>>>>>>>
>>>>>>>> $ cat math/test-float64x-acos.out
>>>>>>>> testing _Float64x (without inline functions)
>>>>>>>> Failure: acos (max_value): Exception "Overflow" set
>>>>>>>> Failure: acos (-max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_downward (max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_downward (-max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_upward (max_value): Exception "Overflow" set
>>>>>>>> Failure: acos_upward (-max_value): Exception "Overflow" set
>>>>>>>>
>>>>>
>>>>> This new static test only checks link failure.  It doesn't check if the static
>>>>> implementation is correct.  We may not have more functional coverage
>>>>> for static libm in the first static libm test patch.  But the first new static
>>>>> libm tests should least expose one static libm failure on x86-64.
>>>>
>>>> The first patch is just a framework so we can selective add new static
>>>> tests, I haven't hook all of the autogenerated tests because this would
>>>> add more cpu and disk usage.
>>>>
>>>> And the test added on libm-test-funcs-*-static rules does check for
>>>> the implementation, using the default math skeleton test (including
>>>> ulp, rounding, exceptions, etc).
>>>>
>>>>>
>>>>>>>> My plan was to eventually track down what might be happening here, and
>>>>>>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
>>>>>>>> tests.
>>>>>>>
>>>>>>> Interesting.  On the other hand, getting --disable-shared to work and
>>>>>>> just run the *entire* test suite could provide value, too.  The last
>>>>>>> time we discussed this we weren't sure if we had static-specific
>>>>>>> failures, but your example shows that we do.
>>>>>>>
>>>>>>
>>>>>> The main problem imho is --disable-shared is essentially a maintainer
>>>>>> option. Although some installed programs will be static linked, it is
>>>>>> really useful on checking if static linking is really working as expected.
>>>>>>
>>>>>> And it also requires *another* build and check iteration, which duplicates
>>>>>> the work required in most cases (since static libraries are still built
>>>>>> on default for --enable-shared).  I tried to help a coworker on support the
>>>>>> --disable-shared and I recall another potential issues was the resulting
>>>>>> disk usage (and thus build requirements) was quite high due glibc poor
>>>>>> organization on static build requirements.
>>>>>>
>>>>>> There also another complication where we will need to constantly add
>>>>>> $(build-shared) and duplicate the CI work to ensure both configure
>>>>>> builds are ok.
>>>>>>
>>>>>> So I really think we should phase-out --disable-shared and work towards
>>>>>> on add more static build tests.
>>>>>
>>>>> Agreed.  We should add one static libm functional test to each libm
>>>>> functional test.  With this, the static libm link tests won't be needed.
>>>>
>>>> For this patchset only added the required one to check for symbols that
>>>> there were some regression with recent fixes. But it should be doable to
>>>> hook all tests for all symbols, although it would require some more Makefile
>>>> rules to hook the tgmath ones.
>>>
>>> The first patch should just add the functional tests for the missing static
>>> libm functions with Makefile changes which can be extended to cover
>>> other libm functions.
>>>
>>
>> And it does on second patch exactly as you suggested:
>>
>> diff --git a/math/Makefile b/math/Makefile
>> index aef9cec1a1..fbb2987248 100644
>> --- a/math/Makefile
>> +++ b/math/Makefile
>> @@ -368,7 +368,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
>>
>>
>>  libm-test-funcs-auto-static =
>> -libm-test-funcs-noauto-static =
>> +libm-test-funcs-noauto-static = \
>> +  fmod \
>> +  # libm-test-funcs-noauto-static
>>  libm-test-funcs-compat-static =
>>  libm-test-funcs-narrow-static =
>>  libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
>>
>>
>> If you check the build directory, it will have a test-<type>-fmod-static
>> that would fail to build without the rest of the patch.
>>
> 
> We already generate libm tests under math:
> 
> math/cabs.c
> math/cabsf128.c
> math/cabsf.c
> math/cabsl.c
> ...
> 

These are not tests, but rather the complex absolute (cabs/cabsf/etc.)
that are autogenerated from the cabs_template.c.

> Can we also generate
> 
> math/cabs-static.c
> ...
> 
> and add them to libm tests?
> 

And it should be simple to add static tests using these new rules:

diff --git a/math/Makefile b/math/Makefile
index ad7fd25995..67618a4385 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -368,6 +368,7 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \


 libm-test-funcs-auto-static = \
+  cabs \
   exp10 \
   # libm-test-funcs-auto-static
 libm-test-funcs-noauto-static = \

x86_64-linux-gnu$ file math/test-*-cabs-static
math/test-double-cabs-static:   ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float-cabs-static:    ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float128-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float32-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float32x-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float64-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-float64x-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
math/test-ldouble-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped

To add all the autogenerated tests, it is a matter to do something like:

diff --git a/math/Makefile b/math/Makefile
index ad7fd25995..b9f1b839ae 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -307,7 +307,7 @@ libm-test-funcs-noauto = canonicalize ceil cimag conj copysign cproj creal \
                         nextup remainder remquo rint round roundeven scalb \
                         scalbln scalbn setpayload setpayloadsig signbit \
                         significand totalorder totalordermag trunc ufromfp \
-                        ufromfpx compat_totalorder compat_totalordermag
+                        ufromfpx
 libm-test-funcs-compat = compat_totalorder compat_totalordermag
 libm-test-funcs-narrow = add div fma mul sqrt sub
 libm-test-funcs-all = $(libm-test-funcs-auto) $(libm-test-funcs-noauto)
@@ -368,13 +368,15 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \


 libm-test-funcs-auto-static = \
-  exp10 \
+  $(libm-test-funcs-auto) \
   # libm-test-funcs-auto-static
 libm-test-funcs-noauto-static = \
-  fmod \
+  $(libm-test-funcs-noauto) \
   # libm-test-funcs-noauto-static
 libm-test-funcs-compat-static =
-libm-test-funcs-narrow-static =
+libm-test-funcs-narrow-static = \
+  $(libm-test-funcs-narrow) \
+  # libm-test-funcs-narrow-static
 libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)

 libm-test-c-auto-static = $(foreach f,$(libm-test-funcs-auto-static),libm-test-$(f)-static.c)

(this won't work because of another missing symbol, __isnanf128, but which
is also simple to fix). 

The approach might be time consuming, since it requires more disk space and
cpu use.  To just build the tests on my machine (Ryzen 5900, 12c) it takes
about 17s, however the extra disk space is quite high:

x86_64-linux-gnu$ stat -c "%s" math/test-*-static | awk '{ total += $0 }; END { print total }' | numfmt --to iec --format "%8.4f"
 3,6716G

I could get a smaller with '-fdata-sections -ffunction-sections -Wl,-gc-sections' (3,5940G),
but it is still a somewhat amount of extra disk space for testing.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[H.J. Lu]

On Mon, Mar 25, 2024 at 10:41 AM Adhemerval Zanella Netto
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 25/03/24 11:52, H.J. Lu wrote:
> > On Mon, Mar 25, 2024 at 7:29 AM Adhemerval Zanella Netto
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 25/03/24 11:25, H.J. Lu wrote:
> >>> On Mon, Mar 25, 2024 at 7:13 AM Adhemerval Zanella Netto
> >>> <adhemerval.zanella@linaro.org> wrote:
> >>>>
> >>>>
> >>>>
> >>>> On 25/03/24 10:34, H.J. Lu wrote:
> >>>>> On Fri, Mar 22, 2024 at 10:46 AM Adhemerval Zanella Netto
> >>>>> <adhemerval.zanella@linaro.org> wrote:
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>> On 22/03/24 12:51, Florian Weimer wrote:
> >>>>>>> * Adhemerval Zanella Netto:
> >>>>>>>
> >>>>>>>> On 22/03/24 03:46, Florian Weimer wrote:
> >>>>>>>>> * Joseph Myers:
> >>>>>>>>>
> >>>>>>>>>> On Thu, 21 Mar 2024, Adhemerval Zanella wrote:
> >>>>>>>>>>
> >>>>>>>>>>> It basically copy the already in place rules for dynamic tests
> >>>>>>>>>>> for auto-generated math tests for all support types.  To avoid
> >>>>>>>>>>> the need to duplicate .inc files, a .SECONDEXPANSION rules is
> >>>>>>>>>>> adeed for the gen-libm-test.py generation.
> >>>>>>>>>>
> >>>>>>>>>> Running the autogenerated tests seems overly complicated when the goal is
> >>>>>>>>>> simply to verify that linking a call succeeds.
> >>>>>>>>>
> >>>>>>>>> Right.  And I would prefer if we could mark compat/otherwise non-static
> >>>>>>>>> symbols in the ABI lists and use those for testing static linking.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> That was my first approach, but then as an experiment I enabled static
> >>>>>>>> build for most of math tests and unexpectedly it has shows some failures
> >>>>>>>> on x86_64:
> >>>>>>>>
> >>>>>>>> FAIL: math/test-float64x-acos
> >>>>>>>> FAIL: math/test-float64x-log10
> >>>>>>>> FAIL: math/test-float64x-log2
> >>>>>>>> FAIL: math/test-float64x-y0
> >>>>>>>> FAIL: math/test-float64x-y1
> >>>>>>>> FAIL: math/test-ldouble-acos
> >>>>>>>> FAIL: math/test-ldouble-log10
> >>>>>>>> FAIL: math/test-ldouble-log2
> >>>>>>>> FAIL: math/test-ldouble-y0
> >>>>>>>> FAIL: math/test-ldouble-y1
> >>>>>>>>
> >>>>>>>> $ cat math/test-float64x-acos.out
> >>>>>>>> testing _Float64x (without inline functions)
> >>>>>>>> Failure: acos (max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos (-max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_downward (max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_downward (-max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_towardzero (max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_towardzero (-max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_upward (max_value): Exception "Overflow" set
> >>>>>>>> Failure: acos_upward (-max_value): Exception "Overflow" set
> >>>>>>>>
> >>>>>
> >>>>> This new static test only checks link failure.  It doesn't check if the static
> >>>>> implementation is correct.  We may not have more functional coverage
> >>>>> for static libm in the first static libm test patch.  But the first new static
> >>>>> libm tests should least expose one static libm failure on x86-64.
> >>>>
> >>>> The first patch is just a framework so we can selective add new static
> >>>> tests, I haven't hook all of the autogenerated tests because this would
> >>>> add more cpu and disk usage.
> >>>>
> >>>> And the test added on libm-test-funcs-*-static rules does check for
> >>>> the implementation, using the default math skeleton test (including
> >>>> ulp, rounding, exceptions, etc).
> >>>>
> >>>>>
> >>>>>>>> My plan was to eventually track down what might be happening here, and
> >>>>>>>> the currently autogenerated tests gave me a nice scaffolding to add coverage
> >>>>>>>> tests.
> >>>>>>>
> >>>>>>> Interesting.  On the other hand, getting --disable-shared to work and
> >>>>>>> just run the *entire* test suite could provide value, too.  The last
> >>>>>>> time we discussed this we weren't sure if we had static-specific
> >>>>>>> failures, but your example shows that we do.
> >>>>>>>
> >>>>>>
> >>>>>> The main problem imho is --disable-shared is essentially a maintainer
> >>>>>> option. Although some installed programs will be static linked, it is
> >>>>>> really useful on checking if static linking is really working as expected.
> >>>>>>
> >>>>>> And it also requires *another* build and check iteration, which duplicates
> >>>>>> the work required in most cases (since static libraries are still built
> >>>>>> on default for --enable-shared).  I tried to help a coworker on support the
> >>>>>> --disable-shared and I recall another potential issues was the resulting
> >>>>>> disk usage (and thus build requirements) was quite high due glibc poor
> >>>>>> organization on static build requirements.
> >>>>>>
> >>>>>> There also another complication where we will need to constantly add
> >>>>>> $(build-shared) and duplicate the CI work to ensure both configure
> >>>>>> builds are ok.
> >>>>>>
> >>>>>> So I really think we should phase-out --disable-shared and work towards
> >>>>>> on add more static build tests.
> >>>>>
> >>>>> Agreed.  We should add one static libm functional test to each libm
> >>>>> functional test.  With this, the static libm link tests won't be needed.
> >>>>
> >>>> For this patchset only added the required one to check for symbols that
> >>>> there were some regression with recent fixes. But it should be doable to
> >>>> hook all tests for all symbols, although it would require some more Makefile
> >>>> rules to hook the tgmath ones.
> >>>
> >>> The first patch should just add the functional tests for the missing static
> >>> libm functions with Makefile changes which can be extended to cover
> >>> other libm functions.
> >>>
> >>
> >> And it does on second patch exactly as you suggested:
> >>
> >> diff --git a/math/Makefile b/math/Makefile
> >> index aef9cec1a1..fbb2987248 100644
> >> --- a/math/Makefile
> >> +++ b/math/Makefile
> >> @@ -368,7 +368,9 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
> >>
> >>
> >>  libm-test-funcs-auto-static =
> >> -libm-test-funcs-noauto-static =
> >> +libm-test-funcs-noauto-static = \
> >> +  fmod \
> >> +  # libm-test-funcs-noauto-static
> >>  libm-test-funcs-compat-static =
> >>  libm-test-funcs-narrow-static =
> >>  libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
> >>
> >>
> >> If you check the build directory, it will have a test-<type>-fmod-static
> >> that would fail to build without the rest of the patch.
> >>
> >
> > We already generate libm tests under math:
> >
> > math/cabs.c
> > math/cabsf128.c
> > math/cabsf.c
> > math/cabsl.c
> > ...
> >
>
> These are not tests, but rather the complex absolute (cabs/cabsf/etc.)
> that are autogenerated from the cabs_template.c.
>
> > Can we also generate
> >
> > math/cabs-static.c
> > ...
> >
> > and add them to libm tests?
> >
>
> And it should be simple to add static tests using these new rules:
>
> diff --git a/math/Makefile b/math/Makefile
> index ad7fd25995..67618a4385 100644
> --- a/math/Makefile
> +++ b/math/Makefile
> @@ -368,6 +368,7 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
>
>
>  libm-test-funcs-auto-static = \
> +  cabs \
>    exp10 \
>    # libm-test-funcs-auto-static
>  libm-test-funcs-noauto-static = \
>
> x86_64-linux-gnu$ file math/test-*-cabs-static
> math/test-double-cabs-static:   ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float-cabs-static:    ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float128-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float32-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float32x-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float64-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-float64x-cabs-static: ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
> math/test-ldouble-cabs-static:  ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), static-pie linked, for GNU/Linux 3.2.0, with debug_info, not stripped
>
> To add all the autogenerated tests, it is a matter to do something like:
>
> diff --git a/math/Makefile b/math/Makefile
> index ad7fd25995..b9f1b839ae 100644
> --- a/math/Makefile
> +++ b/math/Makefile
> @@ -307,7 +307,7 @@ libm-test-funcs-noauto = canonicalize ceil cimag conj copysign cproj creal \
>                          nextup remainder remquo rint round roundeven scalb \
>                          scalbln scalbn setpayload setpayloadsig signbit \
>                          significand totalorder totalordermag trunc ufromfp \
> -                        ufromfpx compat_totalorder compat_totalordermag
> +                        ufromfpx
>  libm-test-funcs-compat = compat_totalorder compat_totalordermag
>  libm-test-funcs-narrow = add div fma mul sqrt sub
>  libm-test-funcs-all = $(libm-test-funcs-auto) $(libm-test-funcs-noauto)
> @@ -368,13 +368,15 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
>
>
>  libm-test-funcs-auto-static = \
> -  exp10 \
> +  $(libm-test-funcs-auto) \
>    # libm-test-funcs-auto-static
>  libm-test-funcs-noauto-static = \
> -  fmod \
> +  $(libm-test-funcs-noauto) \
>    # libm-test-funcs-noauto-static
>  libm-test-funcs-compat-static =
> -libm-test-funcs-narrow-static =
> +libm-test-funcs-narrow-static = \
> +  $(libm-test-funcs-narrow) \
> +  # libm-test-funcs-narrow-static
>  libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
>
>  libm-test-c-auto-static = $(foreach f,$(libm-test-funcs-auto-static),libm-test-$(f)-static.c)
>
> (this won't work because of another missing symbol, __isnanf128, but which
> is also simple to fix).

Another reason to do it.

> The approach might be time consuming, since it requires more disk space and
> cpu use.  To just build the tests on my machine (Ryzen 5900, 12c) it takes
> about 17s, however the extra disk space is quite high:
>
> x86_64-linux-gnu$ stat -c "%s" math/test-*-static | awk '{ total += $0 }; END { print total }' | numfmt --to iec --format "%8.4f"
>  3,6716G
>
> I could get a smaller with '-fdata-sections -ffunction-sections -Wl,-gc-sections' (3,5940G),
> but it is still a somewhat amount of extra disk space for testing.

The current glibc build takes 2.7G on x86-64.  I don't see another 4GB is
a big issue.

-- 
H.J.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Joseph Myers]

On Tue, 26 Mar 2024, H.J. Lu wrote:

> The current glibc build takes 2.7G on x86-64.  I don't see another 4GB is
> a big issue.

That becomes several hundred GB for build-many-glibcs.py (albeit that 
build directories are normally deleted for each configuration after 
testing of that configuration completes, so not all necessarily exist at 
the same time).

-- 
Joseph S. Myers
josmyers@redhat.com

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[Adhemerval Zanella Netto]

On 26/03/24 14:37, Joseph Myers wrote:
> On Tue, 26 Mar 2024, H.J. Lu wrote:
> 
>> The current glibc build takes 2.7G on x86-64.  I don't see another 4GB is
>> a big issue.
> 
> That becomes several hundred GB for build-many-glibcs.py (albeit that 
> build directories are normally deleted for each configuration after 
> testing of that configuration completes, so not all necessarily exist at 
> the same time).
> 

My plan is to send a new patchset version, with static fixes for some ABIs,
but without enabling *all* the tests to be built statically. I think we can 
discuss this in a subsequent patch if this actually is worth.

Re: [PATCH v2 1/6] math: Add support for auto static math tests

[H.J. Lu]

On Tue, Mar 26, 2024 at 10:55 AM Adhemerval Zanella Netto
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 26/03/24 14:37, Joseph Myers wrote:
> > On Tue, 26 Mar 2024, H.J. Lu wrote:
> >
> >> The current glibc build takes 2.7G on x86-64.  I don't see another 4GB is
> >> a big issue.
> >
> > That becomes several hundred GB for build-many-glibcs.py (albeit that
> > build directories are normally deleted for each configuration after
> > testing of that configuration completes, so not all necessarily exist at
> > the same time).
> >
>
> My plan is to send a new patchset version, with static fixes for some ABIs,
> but without enabling *all* the tests to be built statically. I think we can
> discuss this in a subsequent patch if this actually is worth.

If disk space is a concern, we can add a configure option,
---enable-static-math-tests, to enable static math tests.

-- 
H.J.