malloc: Increase tcache fill count from 16 to 32

This avoids a regression in the omnetpp and xalancbmk benchmarks of SPEC. Apparently, these benchmarks are very sensitive to the fill rate in malloc. Suggested-by: Wilco Dijkstra <wilco.dijkstra@arm.com> Tested-by: Wilco Dijkstra <wilco.dijkstra@arm.com>
malloc: Only fill half of the tcache during batch allocation
2026-09-09 05:59:27 +08:00 · 2026-06-30 09:07:19 +02:00 · 2026-06-30 09:07:19 +02:00 · 2026-06-30 09:07:19 +02:00 · 2026-06-26 10:18:36 +08:00 · 2026-06-25 11:21:14 -03:00
484 changed files with 11095 additions and 3394 deletions
@@ -154,30 +154,10 @@ passed to 'configure'.  For example:

     NOTE: '--enable-cet' is only supported on x86_64 and x32.

-'--enable-memory-tagging'
-     Enable memory tagging support if the architecture supports it.
-     When the GNU C Library is built with this option then the resulting
-     library will be able to control the use of tagged memory when
-     hardware support is present by use of the tunable
-     'glibc.mem.tagging'.  This includes the generation of tagged memory
-     when using the 'malloc' APIs.
-
-     At present only AArch64 platforms with MTE provide this
-     functionality, although the library will still operate (without
-     memory tagging) on older versions of the architecture.
-
-     The default is to disable support for memory tagging.
-
 '--disable-profile'
     Don't build libraries with profiling information.  You may want to
     use this option if you don't plan to do profiling.

-'--enable-static-nss'
-     Compile static versions of the NSS (Name Service Switch) libraries.
-     This is not recommended because it defeats the purpose of NSS; a
-     program linked statically with the NSS libraries cannot be
-     dynamically reconfigured to use a different name database.
-
 '--enable-hardcoded-path-in-tests'
     By default, dynamic tests are linked to run with the installed C
     library.  This option hardcodes the newly built C library path in
@@ -9,6 +9,15 @@ Version 2.44

 Major new features:

+* A new tunable, glibc.elf.thp, is added to map read-only segments with
+  Transparent Huge Pages (THP) if THP isn't disable in kernel.  When
+  glibc.elf.thp is set to 1, malloc uses the actual kernel THP mode
+  instead of defaulting to madvise mode and madvise_thp will stop issuing
+  MADV_HUGEPAGE if kernel THP mode is always.
+
+* THP page size in malloc is capped to MAX_THP_PAGESIZE.  If THP page
+  size is above MAX_THP_PAGESIZE, THP in malloc is disabled.
+
 * Additional optimized and correctly rounded mathematical functions have
  been imported from the CORE-MATH project, in particular cosh, sinh, and
  tanh.
@@ -21,6 +30,13 @@ Major new features:
 * Static PIE is now supported for arm-*-linux-gnueabi.  It requires toolchain
  support to correctly set the expected linker options.

+* On AArch64 targets that support Guarded Control Stack extension all GCS
+  operations (including status, write on shadow stack, and push to shadow
+  stack) are locked after enabling GCS with ENFORCED or OVERRIDE GCS policy.
+  When a GCS operation is locked, a program cannot change this operation
+  status via prctl syscall.  This prevents disabling or corrupting GCS
+  shadow stack during runtime.
+
 Deprecated and removed features, and other changes affecting compatibility:

 * Although malloc and related functions currently return pointers
@@ -32,6 +48,15 @@ Deprecated and removed features, and other changes affecting compatibility:

 * The s390-linux-gnu (31bit) configuration is no longer supported.

+* The --enable-memory-tagging configure option has been removed.
+  The corresponding AArch64-specific functionality that was previously
+  activated by this flag has been removed as well.
+
+* The --enable-static-nss configure option has been removed.  It had no
+  effect on the build since the NSS reorganization in glibc 2.33; its only
+  remaining behavior was to suppress the link-time warnings on the NSS
+  interface functions in libc.a, which are now emitted unconditionally.
+
 Changes to build and runtime requirements:

  [Add changes to build and runtime requirements here]
@@ -262,7 +262,7 @@ tzdata:
 # The project is distribute here:
 #       https://gitlab.inria.fr/core-math/core-math/
 core-math:
-  # src/binary64/acosh/acosh.c, revision 1bd85b89
+  # src/binary64/acosh/acosh.c, revision 887cab6f
  sysdeps/ieee754/dbl-64/e_acosh.c
  # src/binary64/atanh/atanh.c, revision 532e37dc
  sysdeps/ieee754/dbl-64/e_atanh.c
@@ -332,3 +332,524 @@ core-math:
  sysdeps/ieee754/flt-32/s_tanhf.c
  # src/binary32/tanpi/tanpif.c, revision 3bbf907
  sysdeps/ieee754/flt-32/s_tanpif.c
+
+# The following files are imported from the Arm Optimized-Routines project,
+# with adjustments made to follow glibc code style and integrate with
+# glibc-specific infrastructure where needed.
+#
+# The project is distributed here:
+#       https://github.com/ARM-software/optimized-routines/
+arm-optimized-routines:
+  # Math routines
+  # math/math_config.h, revision 712aa21
+  sysdeps/ieee754/flt-32/math_config.h
+  # math/math_config.h, revision 712aa21
+  sysdeps/ieee754/dbl-64/math_config.h
+  # math/math_err.c, revision 189dfef
+  sysdeps/ieee754/dbl-64/math_err.c
+  # math/math_errf.c, revision 189dfef
+  sysdeps/ieee754/flt-32/math_errf.c
+  # math/cosf.c, revision aec783d
+  sysdeps/ieee754/flt-32/s_cosf.c
+  # math/exp2f.c, revision 712aa21
+  sysdeps/ieee754/flt-32/e_exp2f.c
+  # math/exp2f_data.c, revision 189dfef
+  sysdeps/ieee754/flt-32/e_exp2f_data.c
+  # math/expf.c, revision 712aa21
+  sysdeps/ieee754/flt-32/e_expf.c
+  # math/log2f.c, revision 712aa21
+  sysdeps/ieee754/flt-32/e_log2f.c
+  # math/log2f_data.c, revision 189dfef
+  sysdeps/ieee754/flt-32/e_log2f_data.c
+  # math/logf.c, revision 712aa21
+  sysdeps/ieee754/flt-32/e_logf.c
+  # math/logf_data.c, revision c0136f1
+  sysdeps/ieee754/flt-32/e_logf_data.c
+  # math/powf.c, revision 712aa21
+  sysdeps/ieee754/flt-32/e_powf.c
+  # math/powf_log2_data.c, revision 189dfef
+  sysdeps/ieee754/flt-32/e_powf_log2_data.c
+  # math/sincosf.c, revision af29d39
+  sysdeps/ieee754/flt-32/s_sincosf.c
+  # math/sincosf.h, revision aed553c
+  sysdeps/ieee754/flt-32/s_sincosf.h
+  # math/sincosf_data.c, revision 189dfef
+  sysdeps/ieee754/flt-32/s_sincosf_data.c
+  # math/sinf.c, revision aec783d
+  sysdeps/ieee754/flt-32/s_sinf.c
+  # math/exp.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_exp.c
+  # math/exp10.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_exp10.c
+  # math/exp2.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_exp2.c
+  # math/exp_data.c, revision c013701
+  sysdeps/ieee754/dbl-64/e_exp_data.c
+  # math/log.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_log.c
+  # math/log2.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_log2.c
+  # math/log2_data.c, revision 189dfef
+  sysdeps/ieee754/dbl-64/e_log2_data.c
+  # math/log_data.c, revision 189dfef
+  sysdeps/ieee754/dbl-64/e_log_data.c
+  # math/pow.c, revision 712aa21
+  sysdeps/ieee754/dbl-64/e_pow.c
+  # math/pow_log_data.c, revision 189dfef
+  sysdeps/ieee754/dbl-64/e_pow_log_data.c
+  # Mathvec routines
+  # math/math_config.h, revision 712aa21
+  sysdeps/aarch64/fpu/vecmath_config.h
+  # math/aarch64/v_erf_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/erf_data.c
+  # math/aarch64/v_erfc_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/erfc_data.c
+  # math/aarch64/v_erfcf_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/erfcf_data.c
+  # math/aarch64/v_erff_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/erff_data.c
+  # math/aarch64/v_exp_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_exp_data.c
+  # math/aarch64/v_exp_tail_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_exp_tail_data.c
+  # math/aarch64/v_log10_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_log10_data.c
+  # math/aarch64/v_log2_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_log2_data.c
+  # math/aarch64/v_log_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_log_data.c
+  # math/aarch64/v_pow_exp_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_pow_exp_data.c
+  # math/aarch64/v_pow_log_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_pow_log_data.c
+  # math/aarch64/v_powf_data.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/v_powf_data.c
+  # math/aarch64/sve/acos.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/acos.c
+  # math/aarch64/sve/acosf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/acosf.c
+  # math/aarch64/sve/acosh.c, revision 8b665af
+  sysdeps/aarch64/fpu/sve/acosh.c
+  # math/aarch64/sve/acoshf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/acoshf.c
+  # math/aarch64/sve/acospi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/acospi.c
+  # math/aarch64/sve/acospif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/acospif.c
+  # math/aarch64/sve/asin.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/asin.c
+  # math/aarch64/sve/asinf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/asinf.c
+  # math/aarch64/sve/asinh.c, revision 9bf4cfc
+  sysdeps/aarch64/fpu/sve/asinh.c
+  # math/aarch64/sve/asinhf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/asinhf.c
+  # math/aarch64/sve/asinpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/asinpi.c
+  # math/aarch64/sve/asinpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/asinpif.c
+  # math/aarch64/sve/atan.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atan.c
+  # math/aarch64/sve/atan2.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atan2.c
+  # math/aarch64/sve/atan2f.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atan2f.c
+  # math/aarch64/sve/atan2pi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atan2pi.c
+  # math/aarch64/sve/atan2pif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atan2pif.c
+  # math/aarch64/sve/atanf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atanf.c
+  # math/aarch64/sve/atanh.c, revision 29c7342
+  sysdeps/aarch64/fpu/sve/atanh.c
+  # math/aarch64/sve/atanhf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atanhf.c
+  # math/aarch64/sve/atanpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atanpi.c
+  # math/aarch64/sve/atanpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/atanpif.c
+  # math/aarch64/sve/cbrt.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/cbrt.c
+  # math/aarch64/sve/cbrtf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/cbrtf.c
+  # math/aarch64/sve/cos.c, revision 99cbbad
+  sysdeps/aarch64/fpu/sve/cos.c
+  # math/aarch64/sve/cosf.c, revision 25aa012
+  sysdeps/aarch64/fpu/sve/cosf.c
+  # math/aarch64/sve/cosh.c, revision 242a017
+  sysdeps/aarch64/fpu/sve/cosh.c
+  # math/aarch64/sve/coshf.c, revision 2fff60c
+  sysdeps/aarch64/fpu/sve/coshf.c
+  # math/aarch64/sve/cospi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/cospi.c
+  # math/aarch64/sve/cospif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/cospif.c
+  # math/aarch64/sve/erf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/erf.c
+  # math/aarch64/sve/erfc.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/erfc.c
+  # math/aarch64/sve/erfcf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/erfcf.c
+  # math/aarch64/sve/erff.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/erff.c
+  # math/aarch64/sve/exp.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp.c
+  # math/aarch64/sve/exp10.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp10.c
+  # math/aarch64/sve/exp10f.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp10f.c
+  # math/aarch64/sve/exp10m1.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp10m1.c
+  # math/aarch64/sve/exp10m1f.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp10m1f.c
+  # math/aarch64/sve/exp2.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp2.c
+  # math/aarch64/sve/exp2f.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp2f.c
+  # math/aarch64/sve/exp2m1.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp2m1.c
+  # math/aarch64/sve/exp2m1f.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/exp2m1f.c
+  # math/aarch64/sve/expf.c, revision 47044a5
+  sysdeps/aarch64/fpu/sve/expf.c
+  # math/aarch64/sve/expm1.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/expm1.c
+  # math/aarch64/sve/expm1f.c, revision d664b69
+  sysdeps/aarch64/fpu/sve/expm1f.c
+  # math/aarch64/sve/hypot.c, revision 74d699d
+  sysdeps/aarch64/fpu/sve/hypot.c
+  # math/aarch64/sve/hypotf.c, revision 74d699d
+  sysdeps/aarch64/fpu/sve/hypotf.c
+  # math/aarch64/sve/log.c, revision 91b052e
+  sysdeps/aarch64/fpu/sve/log.c
+  # math/aarch64/sve/log10.c, revision 91b052e
+  sysdeps/aarch64/fpu/sve/log10.c
+  # math/aarch64/sve/log10f.c, revision 8ca4cc0
+  sysdeps/aarch64/fpu/sve/log10f.c
+  # math/aarch64/sve/log10p1.c, revision 166744d
+  sysdeps/aarch64/fpu/sve/log10p1.c
+  # math/aarch64/sve/log10p1f.c, revision 8124d30
+  sysdeps/aarch64/fpu/sve/log10p1f.c
+  # math/aarch64/sve/log1p.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/log1p.c
+  # math/aarch64/sve/log1pf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/log1pf.c
+  # math/aarch64/sve/log2.c, revision 91b052e
+  sysdeps/aarch64/fpu/sve/log2.c
+  # math/aarch64/sve/log2f.c, revision 8ca4cc0
+  sysdeps/aarch64/fpu/sve/log2f.c
+  # math/aarch64/sve/log2p1.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/log2p1.c
+  # math/aarch64/sve/log2p1f.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/log2p1f.c
+  # math/aarch64/sve/logf.c, revision 8ca4cc0
+  sysdeps/aarch64/fpu/sve/logf.c
+  # math/aarch64/sve/pow.c, revision 2c38e83
+  sysdeps/aarch64/fpu/sve/pow.c
+  # math/aarch64/sve/powf.c, revision 2c38e83
+  sysdeps/aarch64/fpu/sve/powf.c
+  # math/aarch64/sve/powr.c, revision 30da949
+  sysdeps/aarch64/fpu/sve/powr.c
+  # math/aarch64/sve/powrf.c, revision e2bca42
+  sysdeps/aarch64/fpu/sve/powrf.c
+  # math/aarch64/sve/rsqrt.c, revision 4fc7374
+  sysdeps/aarch64/fpu/sve/rsqrt.c
+  # math/aarch64/sve/rsqrtf.c, revision b1bc8ba
+  sysdeps/aarch64/fpu/sve/rsqrtf.c
+  # math/aarch64/sve/sin.c, revision 99cbbad
+  sysdeps/aarch64/fpu/sve/sin.c
+  # math/aarch64/sve/sinf.c, revision 25aa012
+  sysdeps/aarch64/fpu/sve/sinf.c
+  # math/aarch64/sve/sinh.c, revision 242a017
+  sysdeps/aarch64/fpu/sve/sinh.c
+  # math/aarch64/sve/sinhf.c, revision 2fff60c
+  sysdeps/aarch64/fpu/sve/sinhf.c
+  # math/aarch64/sve/sinpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/sinpi.c
+  # math/aarch64/sve/sinpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/sinpif.c
+  # math/aarch64/sve/tan.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/tan.c
+  # math/aarch64/sve/tanf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/tanf.c
+  # math/aarch64/sve/tanh.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/tanh.c
+  # math/aarch64/sve/tanhf.c, revision 2fff60c
+  sysdeps/aarch64/fpu/sve/tanhf.c
+  # math/aarch64/sve/tanpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/tanpi.c
+  # math/aarch64/sve/tanpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/sve/tanpif.c
+  # math/aarch64/sve/sv_exp_special_inline.h, revision d664b69
+  sysdeps/aarch64/fpu/sve/sv_exp_special_inline.h
+  # math/aarch64/sve/sv_expf_inline.h, revision ba35b32
+  sysdeps/aarch64/fpu/sve/sv_expf_inline.h
+  # math/aarch64/sve/sv_expf_special_inline.h, revision d664b69
+  sysdeps/aarch64/fpu/sve/sv_expf_special_inline.h
+  # math/aarch64/sve/sv_expm1f_inline.h, revision 78cd003
+  sysdeps/aarch64/fpu/sve/sv_expm1f_inline.h
+  # math/aarch64/sve/sv_log1p_inline.h, revision 7d08237
+  sysdeps/aarch64/fpu/sve/sv_log1p_inline.h
+  # math/aarch64/sve/sv_log1pf_inline.h, revision a386525
+  sysdeps/aarch64/fpu/sve/sv_log1pf_inline.h
+  # math/aarch64/sve/sv_pow_inline.h, revision 30da949
+  sysdeps/aarch64/fpu/sve/sv_pow_inline.h
+  # math/aarch64/sve/sv_powf_inline.h, revision 30da949
+  sysdeps/aarch64/fpu/sve/sv_powf_inline.h
+  # math/aarch64/sve/sv_poly_f32.h, revision 5d5e6e6
+  sysdeps/aarch64/fpu/sve/poly_sve_f32.h
+  # math/aarch64/sve/sv_poly_f64.h, revision 5d5e6e6
+  sysdeps/aarch64/fpu/sve/poly_sve_f64.h
+  # math/aarch64/sve/sv_poly_generic.h, revision 5d5e6e6
+  sysdeps/aarch64/fpu/sve/poly_sve_generic.h
+  # math/aarch64/sve/sv_math.h, revision 7361ef6
+  sysdeps/aarch64/fpu/sve/sv_math.h
+  # math/aarch64/sve/sv_trig_fallback.h, revision 99cbbad
+  sysdeps/aarch64/fpu/sve/sv_trig_fallback.h
+  # math/aarch64/sve/sv_trigf_fallback.h, revision 25aa012
+  sysdeps/aarch64/fpu/sve/sv_trigf_fallback.h
+  # math/aarch64/advsimd/acos.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/acos.c
+  # math/aarch64/advsimd/acosf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/acosf.c
+  # math/aarch64/advsimd/acosh.c, revision 188e75a
+  sysdeps/aarch64/fpu/advsimd/acosh.c
+  # math/aarch64/advsimd/acoshf.c, revision af3851e
+  sysdeps/aarch64/fpu/advsimd/acoshf.c
+  # math/aarch64/advsimd/acospi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/acospi.c
+  # math/aarch64/advsimd/acospif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/acospif.c
+  # math/aarch64/advsimd/asin.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/asin.c
+  # math/aarch64/advsimd/asinf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/asinf.c
+  # math/aarch64/advsimd/asinh.c, revision bac1b4f
+  sysdeps/aarch64/fpu/advsimd/asinh.c
+  # math/aarch64/advsimd/asinhf.c, revision af3851e
+  sysdeps/aarch64/fpu/advsimd/asinhf.c
+  # math/aarch64/advsimd/asinpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/asinpi.c
+  # math/aarch64/advsimd/asinpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/asinpif.c
+  # math/aarch64/advsimd/atan.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atan.c
+  # math/aarch64/advsimd/atan2.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atan2.c
+  # math/aarch64/advsimd/atan2f.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atan2f.c
+  # math/aarch64/advsimd/atan2pi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atan2pi.c
+  # math/aarch64/advsimd/atan2pif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atan2pif.c
+  # math/aarch64/advsimd/atanf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atanf.c
+  # math/aarch64/advsimd/atanh.c, revision 281cb3a
+  sysdeps/aarch64/fpu/advsimd/atanh.c
+  # math/aarch64/advsimd/atanhf.c, revision d852158
+  sysdeps/aarch64/fpu/advsimd/atanhf.c
+  # math/aarch64/advsimd/atanpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atanpi.c
+  # math/aarch64/advsimd/atanpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/atanpif.c
+  # math/aarch64/advsimd/cbrt.c, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/cbrt.c
+  # math/aarch64/advsimd/cbrtf.c, revision 6c74650
+  sysdeps/aarch64/fpu/advsimd/cbrtf.c
+  # math/aarch64/advsimd/cos.c, revision 677a12b
+  sysdeps/aarch64/fpu/advsimd/cos.c
+  # math/aarch64/advsimd/cosf.c, revision 15c35d9
+  sysdeps/aarch64/fpu/advsimd/cosf.c
+  # math/aarch64/advsimd/cosh.c, revision 447bbaa
+  sysdeps/aarch64/fpu/advsimd/cosh.c
+  # math/aarch64/advsimd/coshf.c, revision 45237ba
+  sysdeps/aarch64/fpu/advsimd/coshf.c
+  # math/aarch64/advsimd/cospi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/cospi.c
+  # math/aarch64/advsimd/cospif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/cospif.c
+  # math/aarch64/advsimd/erf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/erf.c
+  # math/aarch64/advsimd/erfc.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/erfc.c
+  # math/aarch64/advsimd/erfcf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/erfcf.c
+  # math/aarch64/advsimd/erff.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/erff.c
+  # math/aarch64/advsimd/exp.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/exp.c
+  # math/aarch64/advsimd/exp10.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/exp10.c
+  # math/aarch64/advsimd/exp10f.c, revision 69d38dd
+  sysdeps/aarch64/fpu/advsimd/exp10f.c
+  # math/aarch64/advsimd/exp10m1.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/exp10m1.c
+  # math/aarch64/advsimd/exp10m1f.c, revision a5092e8
+  sysdeps/aarch64/fpu/advsimd/exp10m1f.c
+  # math/aarch64/advsimd/exp2.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/exp2.c
+  # math/aarch64/advsimd/exp2f.c, revision 69d38dd
+  sysdeps/aarch64/fpu/advsimd/exp2f.c
+  # math/aarch64/advsimd/exp2m1.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/exp2m1.c
+  # math/aarch64/advsimd/exp2m1f.c, revision a5092e8
+  sysdeps/aarch64/fpu/advsimd/exp2m1f.c
+  # math/aarch64/advsimd/expf.c, revision 69d38dd
+  sysdeps/aarch64/fpu/advsimd/expf.c
+  # math/aarch64/advsimd/expm1.c, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/expm1.c
+  # math/aarch64/advsimd/expm1f.c, revision a5092e8
+  sysdeps/aarch64/fpu/advsimd/expm1f.c
+  # math/aarch64/advsimd/hypot.c, revision 09f8d05
+  sysdeps/aarch64/fpu/advsimd/hypot.c
+  # math/aarch64/advsimd/hypotf.c, revision 99dff4f
+  sysdeps/aarch64/fpu/advsimd/hypotf.c
+  # math/aarch64/advsimd/log.c, revision 0345857
+  sysdeps/aarch64/fpu/advsimd/log.c
+  # math/aarch64/advsimd/log10.c, revision 77aff35
+  sysdeps/aarch64/fpu/advsimd/log10.c
+  # math/aarch64/advsimd/log10f.c, revision ff1596f
+  sysdeps/aarch64/fpu/advsimd/log10f.c
+  # math/aarch64/advsimd/log10p1.c, revision 7fc8510
+  sysdeps/aarch64/fpu/advsimd/log10p1.c
+  # math/aarch64/advsimd/log10p1f.c, revision 58cd796
+  sysdeps/aarch64/fpu/advsimd/log10p1f.c
+  # math/aarch64/advsimd/log1p.c, revision 355a985
+  sysdeps/aarch64/fpu/advsimd/log1p.c
+  # math/aarch64/advsimd/log1pf.c, revision 5cf8408
+  sysdeps/aarch64/fpu/advsimd/log1pf.c
+  # math/aarch64/advsimd/log2.c, revision b8deb33
+  sysdeps/aarch64/fpu/advsimd/log2.c
+  # math/aarch64/advsimd/log2f.c, revision b98f80d
+  sysdeps/aarch64/fpu/advsimd/log2f.c
+  # math/aarch64/advsimd/log2p1.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/log2p1.c
+  # math/aarch64/advsimd/log2p1f.c, revision 58cd796
+  sysdeps/aarch64/fpu/advsimd/log2p1f.c
+  # math/aarch64/advsimd/logf.c, revision 1b15b12
+  sysdeps/aarch64/fpu/advsimd/logf.c
+  # math/aarch64/advsimd/finite_pow.h, revision 30da949
+  sysdeps/aarch64/fpu/advsimd/finite_pow.h
+  # math/pow_common.h, revision 30da949
+  sysdeps/aarch64/fpu/pow_common.h
+  # math/powf_common.h, revision 30da949
+  sysdeps/aarch64/fpu/powf_common.h
+  # math/aarch64/advsimd/pow.c, revision 30da949
+  sysdeps/aarch64/fpu/advsimd/pow.c
+  # math/aarch64/advsimd/powf.c, revision 30da949
+  sysdeps/aarch64/fpu/advsimd/powf.c
+  # math/aarch64/advsimd/powr.c, revision 30da949
+  sysdeps/aarch64/fpu/advsimd/powr.c
+  # math/aarch64/advsimd/powrf.c, revision e2bca42
+  sysdeps/aarch64/fpu/advsimd/powrf.c
+  # math/aarch64/advsimd/rsqrt.c, revision 0945eab
+  sysdeps/aarch64/fpu/advsimd/rsqrt.c
+  # math/aarch64/advsimd/rsqrtf.c, revision 88e9cc9
+  sysdeps/aarch64/fpu/advsimd/rsqrtf.c
+  # math/aarch64/advsimd/sin.c, revision 677a12b
+  sysdeps/aarch64/fpu/advsimd/sin.c
+  # math/aarch64/advsimd/sinf.c, revision 15c35d9
+  sysdeps/aarch64/fpu/advsimd/sinf.c
+  # math/aarch64/advsimd/sinh.c, revision 447bbaa
+  sysdeps/aarch64/fpu/advsimd/sinh.c
+  # math/aarch64/advsimd/sinhf.c, revision 45237ba
+  sysdeps/aarch64/fpu/advsimd/sinhf.c
+  # math/aarch64/advsimd/sinpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/sinpi.c
+  # math/aarch64/advsimd/sinpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/sinpif.c
+  # math/aarch64/advsimd/tan.c, revision a8bbb87
+  sysdeps/aarch64/fpu/advsimd/tan.c
+  # math/aarch64/advsimd/tanf.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/tanf.c
+  # math/aarch64/advsimd/tanh.c, revision 447bbaa
+  sysdeps/aarch64/fpu/advsimd/tanh.c
+  # math/aarch64/advsimd/tanhf.c, revision 45237ba
+  sysdeps/aarch64/fpu/advsimd/tanhf.c
+  # math/aarch64/advsimd/tanpi.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/tanpi.c
+  # math/aarch64/advsimd/tanpif.c, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/tanpif.c
+  # math/aarch64/advsimd/v_exp_special_case_inline.h, revision dce5dab
+  sysdeps/aarch64/fpu/advsimd/v_exp_special_case_inline.h
+  # math/aarch64/advsimd/v_expf_inline.h, revision 747e0e1
+  sysdeps/aarch64/fpu/advsimd/v_expf_inline.h
+  # math/aarch64/advsimd/v_expf_special_inline.h, revision a5092e8
+  sysdeps/aarch64/fpu/advsimd/v_expf_special_inline.h
+  # math/aarch64/advsimd/v_expm1_inline.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/v_expm1_inline.h
+  # math/aarch64/advsimd/v_expm1f_inline.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/v_expm1f_inline.h
+  # math/aarch64/advsimd/v_log1p_inline.h, revision 1aad38d
+  sysdeps/aarch64/fpu/advsimd/v_log1p_inline.h
+  # math/aarch64/advsimd/v_log1pf_inline.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/v_log1pf_inline.h
+  # math/aarch64/advsimd/v_pow_inline.h, revision efde0c7
+  sysdeps/aarch64/fpu/advsimd/v_pow_inline.h
+  # math/aarch64/advsimd/v_powf_inline.h, revision 5b06a16
+  sysdeps/aarch64/fpu/advsimd/v_powf_inline.h
+  # math/aarch64/advsimd/v_powrf_inline.h, revision 30da949
+  sysdeps/aarch64/fpu/advsimd/v_powrf_inline.h
+  # math/aarch64/advsimd/v_poly_f32.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/poly_advsimd_f32.h
+  # math/aarch64/advsimd/v_poly_f64.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/poly_advsimd_f64.h
+  # math/poly_generic.h, revision 0a6ab6d
+  sysdeps/aarch64/fpu/advsimd/poly_generic.h
+  # math/aarch64/advsimd/v_math.h, revision 1829557
+  sysdeps/aarch64/fpu/advsimd/v_math.h
+  # math/aarch64/advsimd/v_trig_fallback.h, revision 677a12b
+  sysdeps/aarch64/fpu/advsimd/v_trig_fallback.h
+  # math/aarch64/advsimd/v_trigf_fallback.h, revision 15c35d9
+  sysdeps/aarch64/fpu/advsimd/v_trigf_fallback.h
+  # String routines
+  # string/aarch64/__mtag_tag_region.S, revision 41e5ae5
+  sysdeps/aarch64/__mtag_tag_region.S
+  # string/aarch64/__mtag_tag_zero_region.S, revision 41e5ae5
+  sysdeps/aarch64/__mtag_tag_zero_region.S
+  # string/aarch64/memchr-mte.S, revision 41e5ae5
+  sysdeps/aarch64/memchr.S
+  # string/aarch64/memcmp.S, revision 41e5ae5
+  sysdeps/aarch64/memcmp.S
+  # string/aarch64/memcpy-advsimd.S, revision 41e5ae5
+  sysdeps/aarch64/memcpy.S
+  # string/aarch64/memcpy-mops.S, revision 41e5ae5
+  sysdeps/aarch64/multiarch/memcpy_mops.S
+  # string/aarch64/memcpy-sve.S, revision 71e3640
+  sysdeps/aarch64/multiarch/memcpy_sve.S
+  # string/aarch64/memmove-mops.S, revision 41e5ae5
+  sysdeps/aarch64/multiarch/memmove_mops.S
+  # string/aarch64/memrchr.S, revision 41e5ae5
+  sysdeps/aarch64/memrchr.S
+  # string/aarch64/memset-mops.S, revision 41e5ae5
+  sysdeps/aarch64/multiarch/memset_mops.S
+  # string/aarch64/memset-sve.S, revision 0f71101
+  sysdeps/aarch64/multiarch/memset_sve_zva64.S
+  # string/aarch64/memset.S, revision 098df8c
+  sysdeps/aarch64/memset.S
+  # string/aarch64/stpcpy.S, revision 189dfef
+  sysdeps/aarch64/stpcpy.S
+  # string/aarch64/strchr-mte.S, revision 41e5ae5
+  sysdeps/aarch64/strchr.S
+  # string/aarch64/strchrnul-mte.S, revision 41e5ae5
+  sysdeps/aarch64/strchrnul.S
+  # string/aarch64/strcmp.S, revision 41e5ae5
+  sysdeps/aarch64/strcmp.S
+  # string/aarch64/strcpy.S, revision 41e5ae5
+  sysdeps/aarch64/strcpy.S
+  # string/aarch64/strlen-mte.S, revision 41e5ae5
+  sysdeps/aarch64/strlen.S
+  # string/aarch64/strncmp.S, revision 41e5ae5
+  sysdeps/aarch64/strncmp.S
+  # string/aarch64/strnlen.S, revision 41e5ae5
+  sysdeps/aarch64/strnlen.S
+  # string/aarch64/strrchr-mte.S, revision 41e5ae5
+  sysdeps/aarch64/strrchr.S
+  # string/arm/memchr.S, revision 1eb5d7c
+  sysdeps/arm/armv6t2/memchr.S
+  # string/arm/memcpy.S, revision 1eb5d7c
+  sysdeps/arm/armv7/multiarch/memcpy_impl.S
+  # string/arm/strcmp.S, revision 1eb5d7c
+  sysdeps/arm/armv7/strcmp.S
+  # string/arm/strlen-armv6t2.S, revision 1eb5d7c
+  sysdeps/arm/armv6t2/strlen.S
@@ -1,11 +1,11 @@
 Buffer overread in ns_printrrf with corrupted RDATA field

 The deprecated functions ns_printrrf, ns_printrr and fp_nquery in the
-GNU C Library version 2.2 and newer fail to validate the RDATA content
-against the RDATA length in a DNS response when processing LOC, CERT,
-TKEY or TSIG records, which may allow an attacker to craft a DNS
-response, causing a target application to crash or read uninitialized
-memory.
+GNU C Library version 2.0.1 to version 2.43 fail to validate the RDATA
+content against the RDATA length in a DNS response when processing A6,
+CERT, LOC, TKEY or TSIG records, which may allow an attacker to craft a
+DNS response, causing a target application to crash or read
+uninitialized memory.

 These functions are for application debugging only and hence not in the
 path of code executed by the DNS resolver.  Further, they have been
@@ -15,4 +15,4 @@ interfaces since they may be removed in future versions.

 CVE-Id: CVE-2026-6238
 Public-Date: 2026-04-11
-Vulnerable-Commit: b43b13ac2544b11f35be301d1589b51a8473e32b (2.2)
+Vulnerable-Commit: ee188d555b8c32ad9704a7440cab400af967292f (1.90)
@@ -0,0 +1,20 @@
+Potential stack-based buffer clash during tilde expansion in wordexp
+
+Calling wordexp with a tilde (~) followed by an overly long username
+in the GNU C Library version 2.2.3 to 2.43 may lead to a stack buffer
+clash.
+
+When expanding paths that begin with a tilde (~) followed by a username, the
+internal parse_tilde function extracts the username to determine the user's
+home directory.  The implementation allocates memory for this username directly
+on the stack using the strndupa macro.  Because the size of this allocation
+was determined by the length of the user-supplied input without any bounds
+checks, passing an excessively long username e.g. thousands of characters,
+forces the thread to exhaust its stack space. Thus if an application passes
+untrusted, attacker-controlled input to the wordexp function, an attacker
+can trigger a stack clash.
+
+CVE-Id: CVE-2026-6791
+Public-Date: 2026-06-22
+Vulnerable-Commit: 344af000e1d6e9c7882b9bc48e71cb3f1b5fc03c (2.2.3-114)
+Reported-by: storm
@@ -32,9 +32,6 @@
 /* Define if _Unwind_Find_FDE should be exported from glibc.  */
 #undef  EXPORT_UNWIND_FIND_FDE

-/* Define if static NSS modules are wanted.  */
-#undef	DO_STATIC_NSS
-
 /* Assume that the compiler supports __builtin_expect.
   This macro is necessary for proper compilation of code
   shared between GNU libc and GNU gettext projects.  */
@@ -185,9 +182,6 @@
 /* Define if inlined system calls are available.  */
 #undef HAVE_INLINED_SYSCALLS

-/* Define if memory tagging support should be enabled.  */
-#undef USE_MTAG
-
 /* Package description.  */
 #undef PKGVERSION

@@ -78,12 +78,9 @@ multi-arch = @multi_arch@

 mach-interface-list = @mach_interface_list@

-memory-tagging = @memory_tagging@
-
 # Configuration options.
 build-shared = @shared@
 build-profile = @profile@
-build-static-nss = @static_nss@
 cross-compiling = @cross_compiling@
 force-install = @force_install@
 build-nscd = @build_nscd@
@@ -616,7 +616,6 @@ RELEASE
 VERSION
 mach_interface_list
 DEFINES
-static_nss
 profile
 libc_cv_multidir
 test_enable_cet
@@ -703,7 +702,6 @@ INSTALL_PROGRAM
 base_machine
 build_pt_chown
 build_nscd
-memory_tagging
 enable_werror
 force_install
 bindnow
@@ -805,13 +803,11 @@ enable_hardcoded_path_in_tests
 enable_hidden_plt
 enable_bind_now
 enable_stack_protector
-enable_static_nss
 enable_force_install
 enable_maintainer_mode
 enable_kernel
 enable_werror
 enable_multi_arch
-enable_memory_tagging
 enable_systemtap
 enable_build_nscd
 enable_nscd
@@ -1479,7 +1475,6 @@ Optional Features:
  --enable-stack-protector=[yes|no|all|strong]
                          Use -fstack-protector[-all|-strong] to detect glibc
                          buffer overflows
-  --enable-static-nss     build static NSS modules [default=no]
  --disable-force-install don't force installation of files from this package,
                          even if they are older than the installed files
  --enable-maintainer-mode
@@ -1490,8 +1485,6 @@ Optional Features:
  --disable-werror        do not build with -Werror
  --enable-multi-arch     enable single DSO with optimizations for multiple
                          architectures
-  --enable-memory-tagging enable memory tagging if supported by the
-                          architecture [default=no]
  --enable-systemtap      enable systemtap static probe points [default=no]
  --disable-build-nscd    disable building and installing the nscd daemon
  --disable-nscd          library functions will not contact the nscd daemon
@@ -4618,21 +4611,6 @@ all|yes|no|strong) ;;
 *) as_fn_error $? "Not a valid argument for --enable-stack-protector: \"$enable_stack_protector\"" "$LINENO" 5;;
 esac

-# Check whether --enable-static-nss was given.
-if test ${enable_static_nss+y}
-then :
-  enableval=$enable_static_nss; static_nss=$enableval
-else case e in #(
-  e) static_nss=no ;;
-esac
-fi
-
-if test x"$static_nss" = xyes || test x"$shared" = xno; then
-  static_nss=yes
-  printf "%s\n" "#define DO_STATIC_NSS 1" >>confdefs.h
-
-fi
-
 # Check whether --enable-force-install was given.
 if test ${enable_force_install+y}
 then :
@@ -4690,26 +4668,6 @@ esac
 fi


-# Check whether --enable-memory-tagging was given.
-if test ${enable_memory_tagging+y}
-then :
-  enableval=$enable_memory_tagging; memory_tagging=$enableval
-else case e in #(
-  e) memory_tagging=no ;;
-esac
-fi
-
-if test "$memory_tagging" = yes; then
-  # Only enable this on architectures that support it.
-  case $host_cpu in
-    aarch64)
-      printf "%s\n" "#define USE_MTAG 1" >>confdefs.h
-
-      ;;
-  esac
-fi
-
-
 # Check whether --enable-systemtap was given.
 if test ${enable_systemtap+y}
 then :
@@ -9619,7 +9577,6 @@ libc_cv_multidir=`${CC-cc} $CFLAGS $CPPFLAGS -print-multi-directory`



-
 VERSION=`sed -n -e 's/^#define VERSION "\([^"]*\)"/\1/p' < $srcdir/version.h`
 RELEASE=`sed -n -e 's/^#define RELEASE "\([^"]*\)"/\1/p' < $srcdir/version.h`

@@ -272,19 +272,6 @@ all|yes|no|strong) ;;
 *) AC_MSG_ERROR([Not a valid argument for --enable-stack-protector: "$enable_stack_protector"]);;
 esac

-dnl On some platforms we cannot use dynamic loading.  We must provide
-dnl static NSS modules.
-AC_ARG_ENABLE([static-nss],
-	      AS_HELP_STRING([--enable-static-nss],
-			     [build static NSS modules @<:@default=no@:>@]),
-	      [static_nss=$enableval],
-	      [static_nss=no])
-dnl Enable static NSS also if we build no shared objects.
-if test x"$static_nss" = xyes || test x"$shared" = xno; then
-  static_nss=yes
-  AC_DEFINE(DO_STATIC_NSS)
-fi
-
 AC_ARG_ENABLE([force-install],
 	      AS_HELP_STRING([--disable-force-install],
 			     [don't force installation of files from this package, even if they are older than the installed files]),
@@ -328,21 +315,6 @@ AC_ARG_ENABLE([multi-arch],
 	      [multi_arch=$enableval],
 	      [multi_arch=default])

-AC_ARG_ENABLE([memory-tagging],
-	      AS_HELP_STRING([--enable-memory-tagging],
-			     [enable memory tagging if supported by the architecture @<:@default=no@:>@]),
-	      [memory_tagging=$enableval],
-	      [memory_tagging=no])
-if test "$memory_tagging" = yes; then
-  # Only enable this on architectures that support it.
-  case $host_cpu in
-    aarch64)
-      AC_DEFINE(USE_MTAG)
-      ;;
-  esac
-fi
-AC_SUBST(memory_tagging)
-
 AC_ARG_ENABLE([systemtap],
              [AS_HELP_STRING([--enable-systemtap],
 	       [enable systemtap static probe points @<:@default=no@:>@])],
@@ -2215,7 +2187,6 @@ libc_cv_multidir=`${CC-cc} $CFLAGS $CPPFLAGS -print-multi-directory`
 AC_SUBST(libc_cv_multidir)

 AC_SUBST(profile)
-AC_SUBST(static_nss)

 AC_SUBST(DEFINES)

@@ -44,21 +44,20 @@ extern void __libc_init_first (int argc, char **argv, char **envp);
 #include <tls.h>
 #ifndef SHARED
 # include <dl-osinfo.h>
+# include <dl-reseed-random.h>
+# include <dl-symbol-redir-ifunc.h>
 # ifndef THREAD_SET_STACK_GUARD
 /* Only exported for architectures that don't store the stack guard canary
   in thread local area.  */
 uintptr_t __stack_chk_guard attribute_relro;
 # endif
-# ifndef  THREAD_SET_POINTER_GUARD
-/* Only exported for architectures that don't store the pointer guard
-   value in thread local area.  */
 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden;
-# endif
 #endif

 #ifndef SHARED
 # include <link.h>
 # include <dl-irel.h>
+# include <dl-symbol-redir-ifunc.h>

 # ifdef ELF_MACHINE_IRELA
 #  define IREL_T	ElfW(Rela)
@@ -205,6 +204,7 @@ call_fini (void *unused)
 #endif /* !SHARED */

 #include <libc-start.h>
+#include <dl-exec-post.h>

 STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
 					 MAIN_AUXVEC_DECL),
@@ -294,11 +294,12 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
  /* Set up the pointer guard value.  */
  uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
 							 stack_chk_guard);
-# ifdef THREAD_SET_POINTER_GUARD
-  THREAD_SET_POINTER_GUARD (pointer_chk_guard);
-# else
  __pointer_chk_guard_local = pointer_chk_guard;
-# endif
+
+  /* We do not need the _dl_random value anymore.  Scrub the AT_RANDOM
+     bytes and clear the pointer; on targets with an entropy source, refill
+     the bytes with fresh random data.  */
+  _dl_reseed_random (&_dl_random);

  /* Now that the TCB, canary, and pointer guard are in place, run the
     deferred IFUNC relocations.  For non-PIE static binaries this is
@@ -307,6 +308,11 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
  _dl_relocate_static_pie_ifunc ();
  ARCH_SETUP_IREL ();

+  /* This must run after the IFUNC relocations: _dl_executable_postprocess
+     may call IFUNC-resolved routines.  */
+  struct link_map *main_map = _dl_get_dl_main_map ();
+  _dl_executable_postprocess (main_map, GL(dl_phdr), GL(dl_phnum));
+
  /* Initialize libpthread if linked in.  */
  if (__pthread_initialize_minimal != NULL)
    __pthread_initialize_minimal ();
@@ -270,6 +270,7 @@ tests-static-normal := \
  tst-env-setuid-static \
  tst-getauxval-static \
  tst-linkall-static \
+  tst-ptrguard-static-dlopen \
  tst-single_threaded-pthread-static \
  tst-single_threaded-static \
  tst-tls-allocation-failure-static \
@@ -278,6 +279,7 @@ tests-static-normal := \
  # tests-static-normal

 tests-static-internal := \
+  tst-atrandom-scrub-static \
  tst-dl-printf-static \
  tst-dl_find_object-static \
  tst-env-setuid-tunables \
@@ -547,6 +549,7 @@ tests-internal += \
  neededtest2 \
  neededtest3 \
  neededtest4 \
+  tst-atrandom-scrub \
  tst-audit19a \
  tst-create_format1 \
  tst-dl-hwcaps_split \
@@ -576,6 +579,7 @@ tests-container += \
  tst-dlopen-tlsmodid-container \
  tst-pldd \
  tst-preload-pthread-libc \
+  tst-ptrguard-static-dlopen \
  tst-rootdir \
  # tests-container

@@ -1013,6 +1017,7 @@ modules-names += \
  tst-null-argv-lib \
  tst-p_alignmod-base \
  tst-p_alignmod3 \
+  tst-ptrguard-static-dlopen-mod \
  tst-recursive-tlsmallocmod \
  tst-recursive-tlsmod0 \
  tst-recursive-tlsmod1 \
@@ -1296,6 +1301,7 @@ tests += \
  tst-ifunc-plt-dlopen-bindnow \
  tst-ifunc-resolver-protector \
  tst-ifunc-tls-init \
+  tst-ifunc-tls-init-gd-ld \
  tst-ifunc-tls-write \
  tst-tls-tdata-reloc \
  # tests
@@ -1363,11 +1369,20 @@ modules-names += \
  tst-ifunc-plt-dep \
  tst-ifunc-plt-lib \
  tst-ifunc-resolver-protector-mod \
+  tst-ifunc-tls-init-gd-global-lib \
+  tst-ifunc-tls-init-gd-lib \
+  tst-ifunc-tls-init-ld-lib \
  tst-ifunc-tls-init-lib1 \
  tst-ifunc-tls-init-lib2 \
  tst-ifunc-tls-write-lib \
  tst-tls-tdata-reloc-lib \
  # modules-names
+ifneq (no,$(have-test-mtls-descriptor))
+tests += tst-ifunc-tls-init-tlsdesc
+modules-names += tst-ifunc-tls-init-tlsdesc-lib
+CFLAGS-tst-ifunc-tls-init-tlsdesc-lib.c += \
+  -mtls-dialect=$(have-test-mtls-descriptor)
+endif
 ifeq (no,$(with-lld))
 modules-names += ifuncmod5
 endif
@@ -2407,6 +2422,9 @@ tst-ptrguard1-ARGS = --command "$(host-test-program-cmd) --child"
 CFLAGS-tst-ptrguard1-static.c += -DPTRGUARD_LOCAL
 tst-ptrguard1-static-ARGS = --command "$(objpfx)tst-ptrguard1-static --child"

+# Likewise, the static pointer guard lives in __pointer_chk_guard_local.
+CFLAGS-tst-atrandom-scrub-static.c += -DPTRGUARD_LOCAL
+
 $(objpfx)tst-leaks1-mem.out: $(objpfx)tst-leaks1.out
 	$(common-objpfx)malloc/mtrace $(objpfx)tst-leaks1.mtrace > $@; \
 	$(evaluate-test)
@@ -2522,6 +2540,20 @@ $(objpfx)tst-ifunc-tls-init.out: \
 $(objpfx)tst-ifunc-tls-write: $(objpfx)tst-ifunc-tls-write-lib.so
 $(objpfx)tst-tls-tdata-reloc: $(objpfx)tst-tls-tdata-reloc-lib.so

+$(objpfx)tst-ifunc-tls-init-gd-ld: $(shared-thread-library)
+$(objpfx)tst-ifunc-tls-init-gd-ld.out: \
+  $(objpfx)tst-ifunc-tls-init-gd-lib.so \
+  $(objpfx)tst-ifunc-tls-init-gd-global-lib.so \
+  $(objpfx)tst-ifunc-tls-init-ld-lib.so
+tst-ifunc-tls-init-gd-ld-TUNABLES = glibc.rtld.optional_static_tls=0
+
+ifneq (no,$(have-test-mtls-descriptor))
+$(objpfx)tst-ifunc-tls-init-tlsdesc: $(shared-thread-library)
+$(objpfx)tst-ifunc-tls-init-tlsdesc.out: \
+  $(objpfx)tst-ifunc-tls-init-tlsdesc-lib.so
+tst-ifunc-tls-init-tlsdesc-TUNABLES = glibc.rtld.optional_static_tls=0
+endif # $(have-test-mtls-descriptor)
+
 $(objpfx)tst-unique1.out: $(objpfx)tst-unique1mod1.so \
 			  $(objpfx)tst-unique1mod2.so

@@ -2810,7 +2842,7 @@ $(objpfx)tst-ldconfig-soname.out : tst-ldconfig-soname.sh \

 # Test static linking of all the libraries we can possibly link
 # together.  Note that in some configurations this may be less than the
-# complete list of libraries we build but we try to maxmimize this list.
+# complete list of libraries we build but we try to maximize this list.
 $(objpfx)tst-linkall-static: \
  $(common-objpfx)math/libm.a \
  $(common-objpfx)resolv/libresolv.a \
@@ -3177,6 +3209,9 @@ $(objpfx)tst-tls21mod.so: $(tst-tls-many-dynamic-modules:%=$(objpfx)%.so)
 $(objpfx)tst-getauxval-static.out: $(objpfx)tst-auxvalmod.so
 tst-getauxval-static-ENV = LD_LIBRARY_PATH=$(objpfx):$(common-objpfx)

+$(objpfx)tst-ptrguard-static-dlopen.out: \
+  $(objpfx)tst-ptrguard-static-dlopen-mod.so
+
 $(objpfx)tst-dlmopen-gethostbyname.out: $(objpfx)tst-dlmopen-gethostbyname-mod.so

 $(objpfx)tst-ro-dynamic: $(objpfx)tst-ro-dynamic-mod.so
@@ -485,7 +485,7 @@ _dl_close_worker (struct link_map *map, bool force)
  size_t tls_free_end;
  tls_free_start = tls_free_end = NO_TLS_OFFSET;

-  /* Protects global and module specitic TLS state.  */
+  /* Protects global and module specific TLS state.  */
  __rtld_lock_lock_recursive (GL(dl_load_tls_lock));

  /* We modify the list of loaded objects.  */
@@ -557,7 +557,7 @@ cannot load auxiliary `%s' because of empty dynamic string token "
      /* Copy the binary into position 0.  */
      l_initfini[0] = map->l_searchlist.r_list[map_index];

-      /* Copy the filtees.  */
+      /* Copy the filters.  */
      for (i = 0; i < map_index; ++i)
 	l_initfini[i+1] = map->l_searchlist.r_list[i];

@@ -465,7 +465,7 @@ _dl_find_object (void *pc1, struct dl_find_object *result)
 }
 rtld_hidden_def (_dl_find_object)

-/* Subroutine of _dlfo_process_initial to split out noncontigous link
+/* Subroutine of _dlfo_process_initial to split out noncontiguous link
   maps.  NODELETE is the number of used _dlfo_nodelete_mappings
   elements.  It is incremented as needed, and the new NODELETE value
   is returned.  */
@@ -586,7 +586,7 @@ _dl_find_object_init (void)
      {
        /* Non-contiguous main maps are handled in
           _dlfo_process_initial.  Mark as initialized, but not
-           coverying any valid PC.  */
+           covering any valid PC.  */
        _dlfo_main.map_start = -1;
        _dlfo_main.map_end = -1;
      }
@@ -112,6 +112,7 @@ struct loadcmd
  int prot;                             /* PROT_* bits.  */
 };

+#include <dl-load-post.h>

 /* Iterator for program header segments.  Initialize with
   _dl_pt_load_iterator_init, then either walk PT_LOAD segments via
@@ -215,6 +216,8 @@ _dl_postprocess_loadcmd (struct link_map *l, const ElfW(Ehdr) *header,
    /* Found the program header in this segment.  */
    l->l_phdr = (void *) (uintptr_t) (c->mapstart + header->e_phoff
                                      - c->mapoff);
+
+  _dl_postprocess_loadcmd_extra (l, c);
 }


@@ -658,6 +658,31 @@ dl_open_worker_begin (void *a)

  bool relocation_in_progress = false;

+  /* This only performs the memory allocations.  The actual update of
+     the scopes happens below, after failure is impossible.  */
+  resize_scopes (new);
+
+  /* Increase the size of the GL (dl_tls_dtv_slotinfo_list) data
+     structure.  */
+  bool any_tls = resize_tls_slotinfo (new);
+
+  /* Perform the necessary allocations for adding new global objects
+     to the global scope below.  */
+  if (mode & RTLD_GLOBAL)
+    add_to_global_resize (new);
+
+  /* Install the new modules in the DTV slotinfo and initialise their
+     static TLS *before* relocation, so an IFUNC resolver firing during
+     the relocation loop below can reach its DSO's __thread storage via
+     __tls_get_addr / TLSDESC.  Without this, the resolver's TLS access
+     for a just-loaded module would index into an unallocated DTV slot
+     and crash.  If relocation later fails, the subsequent _dl_close_worker
+     cleans up these slotinfo entries via remove_slotinfo.  */
+  if (any_tls)
+    /* FIXME: This calls _dl_update_slotinfo, which aborts the process
+       on memory allocation failure.  See bug 16134.  */
+    update_tls_slotinfo (new);
+
  /* Perform relocation.  This can trigger lazy binding in IFUNC
     resolvers.  For NODELETE mappings, these dependencies are not
     recorded because the flag has not been applied to the newly
@@ -682,19 +707,6 @@ dl_open_worker_begin (void *a)
    _dl_open_relocate_one_object (args, r, new->l_initfini[i], reloc_mode,
 				  &relocation_in_progress);

-  /* This only performs the memory allocations.  The actual update of
-     the scopes happens below, after failure is impossible.  */
-  resize_scopes (new);
-
-  /* Increase the size of the GL (dl_tls_dtv_slotinfo_list) data
-     structure.  */
-  bool any_tls = resize_tls_slotinfo (new);
-
-  /* Perform the necessary allocations for adding new global objects
-     to the global scope below.  */
-  if (mode & RTLD_GLOBAL)
-    add_to_global_resize (new);
-
  /* Demarcation point: After this, no recoverable errors are allowed.
     All memory allocations for new objects must have happened
     before.  */
@@ -716,19 +728,6 @@ dl_open_worker_begin (void *a)
    _dl_signal_error (ENOMEM, new->l_libname->name, NULL,
 		      N_ ("cannot allocate address lookup data"));

-  /* FIXME: It is unclear whether the order here is correct.
-     Shouldn't new objects be made available for binding (and thus
-     execution) only after there TLS data has been set up fully?
-     Fixing bug 16134 will likely make this distinction less
-     important.  */
-
-  /* Second stage after resize_tls_slotinfo: Update the slotinfo data
-     structures.  */
-  if (any_tls)
-    /* FIXME: This calls _dl_update_slotinfo, which aborts the process
-       on memory allocation failure.  See bug 16134.  */
-    update_tls_slotinfo (new);
-
  /* Notify the debugger all new objects have been relocated.  */
  if (relocation_in_progress)
    LIBC_PROBE (reloc_complete, 3, args->nsid, r, new);
@@ -777,7 +776,7 @@ dl_open_worker (void *a)

 #ifdef SHARED
 	if (was_not_consistent)
-	  /* Avoid redudant/recursive signalling.  */
+	  /* Avoid redundant/recursive signalling.  */
 	  _dl_audit_activity_nsid (nsid, LA_ACT_CONSISTENT);
 #endif
      }
@@ -179,6 +179,12 @@ int _dl_stack_cache_lock;
 #endif
 struct dl_scope_free_list *_dl_scope_free_list;

+#ifdef HAVE_THP
+enum dl_elf_thp_control_t _dl_elf_thp_control;
+enum thp_mode_t _dl_thp_mode;
+size_t _dl_elf_thp_pagesize;
+#endif
+
 #ifdef NEED_DL_SYSINFO
 /* Needed for improved syscall handling on at least x86/Linux.  NB: Don't
   initialize it here to avoid RELATIVE relocation in static PIE.  */
@@ -339,7 +339,7 @@ _dl_determine_tlsoffset (void)
  /* Extra TLS block for internal usage to append at the end of the TLS blocks
     (in allocation order).  The address at which the block is allocated must
     be aligned to 'extra_tls_align'.  The size of the block as returned by
-     '_dl_extra_tls_get_size ()' is always a multiple of the aligment.
+     '_dl_extra_tls_get_size ()' is always a multiple of the alignment.

     On Linux systems this is where the rseq area will be allocated.  On other
     systems it is currently unused and both values will be '0'.  */
@@ -419,7 +419,7 @@ _dl_determine_tlsoffset (void)
  /* Extra TLS block for internal usage to append at the end of the TLS blocks
     (in allocation order).  The address at which the block is allocated must
     be aligned to 'extra_tls_align'.  The size of the block as returned by
-     '_dl_extra_tls_get_size ()' is always a multiple of the aligment.
+     '_dl_extra_tls_get_size ()' is always a multiple of the alignment.

     On Linux systems this is where the rseq area will be allocated.  On other
     systems it is currently unused and both values will be '0'.  */
@@ -699,7 +699,7 @@ _dl_allocate_tls_init (void *result, bool main_thread)
 	     initialization because it would already be set by the
 	     audit setup, which uses the dlopen code and already
 	     clears l_need_tls_init.  Calls with !main_thread from
-	     pthread_create need to initialze TLS for the current
+	     pthread_create need to initialize TLS for the current
 	     thread regardless of namespace.  */
 	  if (map->l_ns != LM_ID_BASE && main_thread)
 	    continue;
@@ -116,11 +116,6 @@ glibc {
  }

  mem {
-    tagging {
-      type: INT_32
-      minval: 0
-      maxval: 255
-    }
    decorate_maps {
      type: INT_32
      minval: 0
@@ -35,6 +35,7 @@
 #include <unsecvars.h>
 #include <dl-cache.h>
 #include <dl-osinfo.h>
+#include <dl-reseed-random.h>
 #include <dl-prop.h>
 #include <dl-vdso.h>
 #include <dl-vdso-setup.h>
@@ -52,6 +53,7 @@
 #include <dl-find_object.h>
 #include <dl-audit-check.h>
 #include <dl-call_tls_init_tp.h>
+#include <dl-exec-post.h>

 #include <assert.h>

@@ -166,12 +168,8 @@ rtld_hidden_data_def (_dl_argv)
 uintptr_t __stack_chk_guard attribute_relro;
 #endif

-/* Only exported for architectures that don't store the pointer guard
-   value in thread local area.  */
 uintptr_t __pointer_chk_guard_local attribute_relro attribute_hidden;
-#ifndef THREAD_SET_POINTER_GUARD
 strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
-#endif

 /* Check that AT_SECURE=0, or that the passed name does not contain
   directories and is not overly long.  Reject empty names
@@ -827,15 +825,12 @@ security_init (void)
  /* Set up the pointer guard as well, if necessary.  */
  uintptr_t pointer_chk_guard
    = _dl_setup_pointer_guard (_dl_random, stack_chk_guard);
-#ifdef THREAD_SET_POINTER_GUARD
-  THREAD_SET_POINTER_GUARD (pointer_chk_guard);
-#endif
  __pointer_chk_guard_local = pointer_chk_guard;

-  /* We do not need the _dl_random value anymore.  The less
-     information we leave behind, the better, so clear the
-     variable.  */
-  _dl_random = NULL;
+  /* We do not need the _dl_random value anymore.  Scrub the AT_RANDOM
+     bytes and clear the pointer; on targets with an entropy source, refill
+     the bytes with fresh random data.  */
+  _dl_reseed_random (&_dl_random);
 }

 #include <setup-vdso.h>
@@ -1209,14 +1204,8 @@ rtld_setup_main_map (struct link_map *main_map)
 	main_map->l_relro_size = ph->p_memsz;
 	break;
      }
-  /* Process program headers again, but scan them backwards since
-     PT_GNU_PROPERTY is close to the end of program headers.   */
-  for (const ElfW(Phdr) *ph = &phdr[phnum]; ph != phdr; --ph)
-    if (ph[-1].p_type == PT_GNU_PROPERTY)
-      {
-	_dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
-	break;
-      }
+
+  _dl_executable_postprocess (main_map, phdr, phnum);

  /* Adjust the address of the TLS initialization image in case
     the executable is actually an ET_DYN object.  */
@@ -1589,6 +1578,9 @@ dl_main (const ElfW(Phdr) *phdr,
 	{
 	  RTLD_TIMING_VAR (start);
 	  rtld_timer_start (&start);
+#ifdef HAVE_THP
+	  _dl_get_thp_config ();
+#endif
 	  _dl_map_object (NULL, rtld_progname, lt_executable, 0,
 			  __RTLD_OPENEXEC, LM_ID_BASE);
 	  rtld_timer_stop (&load_time, start);
@@ -81,5 +81,15 @@ __rtld_static_init (struct link_map *map)
  dl->_dl_find_object = _dl_find_object;
  dl->_dl_readonly_area = _dl_readonly_area;

+  extern uintptr_t __pointer_chk_guard_local attribute_hidden;
+  const ElfW(Sym) *guard_sym
+    = _dl_lookup_direct (map, "__pointer_chk_guard",
+			 0x69f99cab, /* _dl_new_hash output.  */
+			 "GLIBC_PRIVATE",
+			 0x0963cf85); /* _dl_elf_hash output.  */
+  assert (guard_sym != NULL);
+  *(uintptr_t *) DL_SYMBOL_ADDRESS (map, guard_sym)
+    = __pointer_chk_guard_local;
+
  __rtld_static_init_arch (map, dl);
 }
@@ -1,6 +1,5 @@
-/* Test header that defines macros for GNU properties that need to be
-   used in some test assembly files where sysdep.h cannot be included
-   for some reason.
+/* Test header that defines feature-marking macros used in some test
+   assembly files where sysdep.h cannot be included for some reason.
   Copyright (C) 2024-2026 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

@@ -27,7 +26,6 @@
 #define FEATURE_1_PAC 2
 #define FEATURE_1_GCS 4

-/* Add a NT_GNU_PROPERTY_TYPE_0 note.  */
 #define GNU_PROPERTY(type, value)	\
  .section .note.gnu.property, "a";	\
  .p2align 3;				\
@@ -41,7 +39,32 @@
  .word 0;				\
  .text

-/* Add GNU property note with the supported features to all asm code
-   where sysdep.h is included.  */
-GNU_PROPERTY (FEATURE_1_AND, FEATURE_1_BTI|FEATURE_1_PAC|FEATURE_1_GCS)
+#ifdef __ARM_BUILDATTR64_FV
+/* Add AArch64 feature bits build attributes.  */
+# define FEATURE_1_AND_MARK(value)					\
+    .aeabi_subsection aeabi_feature_and_bits, optional, ULEB128;	\
+    .if ((value) & FEATURE_1_BTI);					\
+    .aeabi_attribute Tag_Feature_BTI, 1;				\
+    .else;								\
+    .aeabi_attribute Tag_Feature_BTI, 0;				\
+    .endif;								\
+    .if ((value) & FEATURE_1_GCS);					\
+    .aeabi_attribute Tag_Feature_GCS, 1;				\
+    .else;								\
+    .aeabi_attribute Tag_Feature_GCS, 0;				\
+    .endif;								\
+    .if ((value) & FEATURE_1_PAC);					\
+    .aeabi_attribute Tag_Feature_PAC, 1;				\
+    .else;								\
+    .aeabi_attribute Tag_Feature_PAC, 0;				\
+    .endif;								\
+    .text
+#else
+/* Add a NT_GNU_PROPERTY_TYPE_0 note.  */
+# define FEATURE_1_AND_MARK(value) GNU_PROPERTY (FEATURE_1_AND, value)
+#endif /* __ARM_BUILDATTR64_FV */
+
+/* Add marking with the supported features to all asm code where this header
+   is included.  */
+FEATURE_1_AND_MARK (FEATURE_1_BTI | FEATURE_1_PAC | FEATURE_1_GCS)
 #endif
@@ -0,0 +1 @@
+#include "tst-atrandom-scrub.c"
@@ -0,0 +1,89 @@
+/* Verify the AT_RANDOM bytes do not reveal the guards after startup.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* The loader (security_init) and the static startup code (__libc_start_main)
+   derive the stack and pointer guards from the AT_RANDOM bytes, scrub those
+   bytes, and refill them with fresh entropy unrelated to the guards.  The
+   AT_RANDOM entry is kept, so getauxval (AT_RANDOM) keeps returning 16 random
+   bytes, but they no longer reveal the guards.  Check that neither guard can
+   be reconstructed from AT_RANDOM and that no auxiliary vector entry holds a
+   guard value.  */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/auxv.h>
+
+#include <stackguard-macros.h>
+#include <tls.h>
+#include <support/check.h>
+
+static int
+do_test (void)
+{
+  uintptr_t stack_guard = STACK_CHK_GUARD;
+  uintptr_t pointer_guard = POINTER_CHK_GUARD;
+
+  unsigned char *random = (unsigned char *) getauxval (AT_RANDOM);
+  if (random == NULL)
+    FAIL_UNSUPPORTED ("the kernel did not provide AT_RANDOM");
+
+  printf ("debug: stack guard   = %0*jx\n",
+          (int) (2 * sizeof (uintptr_t)), (uintmax_t) stack_guard);
+  printf ("debug: pointer guard = %0*jx\n",
+          (int) (2 * sizeof (uintptr_t)), (uintmax_t) pointer_guard);
+  printf ("debug: AT_RANDOM     = ");
+  for (int i = 0; i < 16; i++)
+    printf ("%02x", random[i]);
+  printf ("\n");
+
+  /* Sanity check: the guards and AT_RANDOM must all have been populated
+     (not all-zero), otherwise we cannot tell scrub-and-reseed apart from
+     "never set up".  */
+  TEST_VERIFY (stack_guard != 0);
+  TEST_VERIFY (pointer_guard != 0);
+  bool random_all_zero = true;
+  for (int i = 0; i < 16; i++)
+    if (random[i] != 0)
+      {
+        random_all_zero = false;
+        break;
+      }
+  TEST_VERIFY (!random_all_zero);
+
+  /* Reconstruct the guards from the (reseeded) AT_RANDOM bytes the way the
+     loader does and check that they no longer match the live guards.  */
+  uintptr_t recovered_stack;
+  memcpy (&recovered_stack, random, sizeof (recovered_stack));
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+  recovered_stack &= ~(uintptr_t) 0xff;
+#else
+  recovered_stack &= ~((uintptr_t) 0xff << (8 * (sizeof (recovered_stack) - 1)));
+#endif
+  TEST_VERIFY (recovered_stack != stack_guard);
+
+  uintptr_t recovered_pointer;
+  memcpy (&recovered_pointer, random + sizeof (uintptr_t),
+          sizeof (recovered_pointer));
+  TEST_VERIFY (recovered_pointer != pointer_guard);
+
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -46,7 +46,7 @@ do_test (void)

  {
    /* Install the default implementation of libmarkermod1.so.  */
-    char *conf_path = xasprintf ("%s/ld.so.conf", support_sysconfdir_prefix);
+    char *conf_path = xasprintf ("%s/ld.so.conf.d/hwcaps.conf", support_sysconfdir_prefix);
    xmkdirp (support_sysconfdir_prefix, 0777);
    support_write_file_string (conf_path, "/glibc-test/lib\n");
    free (conf_path);
@@ -41,6 +41,7 @@ my_foo (void)

 static __typeof (foo) *
 inhibit_stack_protector
+__attribute_used__
 foo_ifunc (void)
 {
  init_foo ();
@@ -22,6 +22,7 @@
   .rel{a}.plt).  This verifies that every IRELATIVE entry is deferred
   until after .rela.plt has been processed, not just the first one.  */

+#include <sys/cdefs.h>
 #include <stddef.h>

 extern int get_value (void);
@@ -38,14 +39,16 @@ impl_b (void)
  return 2;
 }

-static int (*
-resolve_a (void)) (void)
+static typeof (impl_a) *
+__attribute_used__
+resolve_a (void)
 {
  return get_value () == 42 ? impl_a : NULL;
 }

-static int (*
-resolve_b (void)) (void)
+static typeof (impl_b) *
+__attribute_used__
+resolve_b (void)
 {
  return get_value () == 42 ? impl_b : NULL;
 }
@@ -25,6 +25,8 @@
   always observe an initialised canary; this test guards against any future
   reordering that would break that invariant.  */

+#include <sys/cdefs.h>
+
 #define SENTINEL 0x5A5A1234

 static volatile int resolver_ran;
@@ -44,6 +46,7 @@ impl_ok (int x)
 typedef int (*fn_t) (int);

 static fn_t
+__attribute_used__
 resolver (void)
 {
  /* Buffer + zero-fill force -fstack-protector-all canary code.  */
@@ -50,6 +50,7 @@ impl_ok (int x)
 typedef int (*fn_t) (int);

 static fn_t
+__attribute_used__
 resolver (void)
 {
  /* Buffer forces -fstack-protector-all to emit canary code even with
@@ -0,0 +1,3 @@
+#define TLS_MODEL "global-dynamic"
+#define SENTINEL_STORAGE /* empty */
+#include "tst-ifunc-tls-init-gd-ld-lib-skeleton.c"
@@ -0,0 +1,73 @@
+/* Shared-library skeleton for tst-ifunc-tls-init-gd-ld.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Unlike tst-ifunc-tls-init-lib-skeleton.c, which uses initial-exec and
+   resolves via a single TP-relative load, this skeleton's TLS_MODEL is
+   either "global-dynamic" or "local-dynamic" so the resolver's read of
+   'sentinel' must traverse __tls_get_addr (or the architecture's
+   TLSDESC equivalent).  That dynamic-TLS access can lazily allocate a
+   per-module TLS block, which is the path being exercised.  */
+
+#include <sys/cdefs.h>
+
+#ifndef TLS_MODEL
+# error "tst-ifunc-tls-init-gd-ld-lib-skeleton.c needs TLS_MODEL defined"
+#endif
+
+/* Without static the relocation against the SENTINEL goes through the regular
+   global-symbol lookup path; combined with TLS_MODEL="global-dynamic" this
+   exercises the "global GD" variant rather than the file-local one.  */
+#ifndef SENTINEL_STORAGE
+# define SENTINEL_STORAGE static
+#endif
+
+#define SENTINEL 0x5A5A1234
+
+SENTINEL_STORAGE volatile __thread int sentinel
+  __attribute__ ((tls_model (TLS_MODEL))) = SENTINEL;
+static volatile int last_seen_sentinel;
+
+static int
+impl_ok (void)
+{
+  return SENTINEL;
+}
+
+static int
+impl_bad (void)
+{
+  return 0;
+}
+
+int
+get_last_seen_sentinel (void)
+{
+  return last_seen_sentinel;
+}
+
+static typeof (impl_ok) *
+__attribute_used__
+resolver (void)
+{
+  int s = sentinel;
+  last_seen_sentinel = s;
+  return s == SENTINEL ? impl_ok : impl_bad;
+}
+int ifunc_tls (void) __attribute__ ((ifunc ("resolver")));
+
+int (*fptr) (void) = ifunc_tls;
@@ -0,0 +1,89 @@
+/* Check if dynamic-TLS variables (global-dynamic, local-dynamic) are
+   correctly initialised in IFUNC resolvers reached via dlopen.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* This test dlopens three modules covering the dynamic-TLS access variants:
+
+     gd-lib         file-local 'sentinel' + tls_model("global-dynamic")
+     ld-lib         file-local 'sentinel' + tls_model("local-dynamic")
+     gd-global-lib  external 'sentinel' + tls_model("global-dynamic")
+
+   In each case the IFUNC resolver's read of 'sentinel' must traverse the
+   dynamic-TLS resolution path at the moment the resolver fires during
+   dlopen-time relocation.
+
+   Each variant additionally calls the resolved IFUNC from a thread spawned
+   after dlopen, to verify per-thread DTV propagation for the newly-loaded
+   module.  */
+
+#include <support/check.h>
+#include <support/xdlfcn.h>
+#include <support/xthread.h>
+
+#define SENTINEL 0x5A5A1234
+
+struct ifunc_handles
+{
+  int (*get_last_seen_sentinel) (void);
+  int (**fptr) (void);
+  int (*ifunc_tls) (void);
+};
+
+static void *
+ifunc_caller (void *arg)
+{
+  struct ifunc_handles *h = arg;
+  TEST_COMPARE ((*h->fptr) (), SENTINEL);
+  TEST_COMPARE (h->ifunc_tls (), SENTINEL);
+  return NULL;
+}
+
+static void
+test_lib (const char *soname)
+{
+  void *handle = xdlopen (soname, RTLD_LAZY | RTLD_LOCAL);
+
+  struct ifunc_handles h;
+  h.get_last_seen_sentinel = xdlsym (handle, "get_last_seen_sentinel");
+  h.fptr = xdlsym (handle, "fptr");
+  h.ifunc_tls = xdlsym (handle, "ifunc_tls");
+
+  TEST_COMPARE (h.get_last_seen_sentinel (), SENTINEL);
+
+  TEST_VERIFY (*h.fptr != NULL);
+  TEST_COMPARE ((*h.fptr) (), SENTINEL);
+  TEST_COMPARE (h.ifunc_tls (), SENTINEL);
+
+  /* From a thread spawned *after* the dlopen, which exercises DTV propagation
+     for the new module into a fresh TCB.  */
+  pthread_t consumer = xpthread_create (NULL, ifunc_caller, &h);
+  xpthread_join (consumer);
+
+  xdlclose (handle);
+}
+
+static int
+do_test (void)
+{
+  test_lib ("tst-ifunc-tls-init-gd-lib.so");
+  test_lib ("tst-ifunc-tls-init-ld-lib.so");
+  test_lib ("tst-ifunc-tls-init-gd-global-lib.so");
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -0,0 +1,2 @@
+#define TLS_MODEL "global-dynamic"
+#include "tst-ifunc-tls-init-gd-ld-lib-skeleton.c"
@@ -0,0 +1,2 @@
+#define TLS_MODEL "local-dynamic"
+#include "tst-ifunc-tls-init-gd-ld-lib-skeleton.c"
@@ -20,6 +20,8 @@
   load, so the test is sensitive to whether the static TLS block has been
   populated rather than to any __tls_get_addr / DTV-update timing.  */

+#include <sys/cdefs.h>
+
 #define SENTINEL 0x5A5A1234

 /* The 'volatile' avoids constant fold optimization in impl_ok.  */
@@ -45,7 +47,9 @@ get_last_seen_sentinel (void)
  return last_seen_sentinel;
 }

-static int (*resolver (void)) (void)
+static typeof (impl_ok) *
+__attribute_used__
+resolver (void)
 {
  int s = sentinel;
  last_seen_sentinel = s;
@@ -0,0 +1,3 @@
+#define TLS_MODEL "global-dynamic"
+#define SENTINEL_STORAGE /* empty */
+#include "tst-ifunc-tls-init-gd-ld-lib-skeleton.c"
@@ -0,0 +1,69 @@
+/* Check that an IFUNC resolver in a dlopen'd DSO can read .tdata-initialised
+   __thread storage when the TLS access is compiled as a TLSDESC sequence.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Sibling of tst-ifunc-tls-init-gd-ld, but the TLS access in the loaded
+   DSO is compiled with the TLSDESC dialect (x86 gnu2, aarch64 desc).  */
+
+#include <support/check.h>
+#include <support/xdlfcn.h>
+#include <support/xthread.h>
+
+#define SENTINEL 0x5A5A1234
+
+struct ifunc_handles
+{
+  int (*get_last_seen_sentinel) (void);
+  int (**fptr) (void);
+  int (*ifunc_tls) (void);
+};
+
+static void *
+ifunc_caller (void *arg)
+{
+  struct ifunc_handles *h = arg;
+  TEST_COMPARE ((*h->fptr) (), SENTINEL);
+  TEST_COMPARE (h->ifunc_tls (), SENTINEL);
+  return NULL;
+}
+
+static int
+do_test (void)
+{
+  void *handle = xdlopen ("tst-ifunc-tls-init-tlsdesc-lib.so",
+			  RTLD_LAZY | RTLD_LOCAL);
+
+  struct ifunc_handles h;
+  h.get_last_seen_sentinel = xdlsym (handle, "get_last_seen_sentinel");
+  h.fptr = xdlsym (handle, "fptr");
+  h.ifunc_tls = xdlsym (handle, "ifunc_tls");
+
+  TEST_COMPARE (h.get_last_seen_sentinel (), SENTINEL);
+
+  TEST_VERIFY (*h.fptr != NULL);
+  TEST_COMPARE ((*h.fptr) (), SENTINEL);
+  TEST_COMPARE (h.ifunc_tls (), SENTINEL);
+
+  pthread_t consumer = xpthread_create (NULL, ifunc_caller, &h);
+  xpthread_join (consumer);
+
+  xdlclose (handle);
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -39,6 +39,18 @@ test_tls_ifunc (int (*check_sentinel)(void),
 		int (*check_fptr)(void),
 		int (*check_ifunc_tls)(void))
 {
+  /* Force the IFUNC to be resolved before inspecting what the resolver
+     observed.  In a non-PIE executable the references to the IFUNC are
+     satisfied through a canonical IPLT entry in the executable, which under
+     lazy binding is resolved on first use rather than during startup
+     relocation.  Calling fptr/ifunc_tls here guarantees the resolver has run
+     regardless of PIE-ness or binding mode.   */
+  TEST_VERIFY (check_fptr != NULL);
+  TEST_COMPARE (check_fptr (), SENTINEL);
+
+  /* Issue the ifunc directly as well.  */
+  TEST_COMPARE (check_ifunc_tls (), SENTINEL);
+
  /* Primary check: 'get_last_seen_sentinel' returns the value of the DSO's
     thread-local 'sentinel' as observed by the resolver at the moment it ran
     for the IFUNC reloc that initialised fptr.  The getter is a regular
@@ -46,14 +58,6 @@ test_tls_ifunc (int (*check_sentinel)(void),
     does NOT go through a COPY relocation that could overwrite the resolver's
     write.  */
  TEST_COMPARE (check_sentinel (), SENTINEL);
-
-  /* Secondary check: fptr is set during IFUNC resolver call, then copied into
-     the exe's.  Returns SENTINEL only if the resolver picked impl_ok.  */
-  TEST_VERIFY (check_fptr != NULL);
-  TEST_COMPARE (check_fptr (), SENTINEL);
-
-  /* Sanity check: issue the ifunc.  */
-  TEST_COMPARE (check_ifunc_tls (), SENTINEL);
 }

 static int
@@ -21,6 +21,8 @@
   overwrites counter with MARKER, and the test then reads counter back
   through a getter.  */

+#include <sys/cdefs.h>
+
 #define SENTINEL 0x5A5A1234u
 #define MARKER   0x32125A5Au

@@ -34,7 +36,9 @@ impl (void)
  return 0;
 }

-static unsigned int (*resolver (void)) (void)
+static typeof (impl) *
+__attribute_used__
+resolver (void)
 {
  counter = MARKER;
  return impl;
@@ -0,0 +1,29 @@
+/* Shared object for the static-dlopen pointer guard test.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <setjmp.h>
+
+static jmp_buf jb;
+void (*do_longjmp) (jmp_buf);
+
+void
+foo (void)
+{
+  if (setjmp (jb) == 0)
+    do_longjmp (jb);
+}
@@ -0,0 +1,51 @@
+/* Test that the pointer guard is propagated to ld.so via static dlopen.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* A statically linked program dlopens a shared object; the object's setjmp
+   uses the just-mapped libc.so's pointer guard while the longjmp below uses
+   the program's guard.  Unless __rtld_static_init propagates the guard to
+   the loaded loader the two differ, and the setjmp/longjmp round-trip jumps
+   to a corrupt address and crashes.  */
+
+#include <setjmp.h>
+#include <support/check.h>
+#include <support/xdlfcn.h>
+
+static void
+call_longjmp (jmp_buf jb)
+{
+  longjmp (jb, 1);
+}
+
+static int
+do_test (void)
+{
+  void *h = xdlopen ("tst-ptrguard-static-dlopen-mod.so", RTLD_NOW);
+  void (*foo) (void) = xdlsym (h, "foo");
+  void (**do_longjmp) (jmp_buf) = xdlsym (h, "do_longjmp");
+  *do_longjmp = call_longjmp;
+
+  /* foo () sets the jump buffer and calls back into call_longjmp; a
+     mismatched guard makes the return jump fault.  */
+  foo ();
+
+  xdlclose (h);
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -0,0 +1 @@
+cp $B/elf/tst-ptrguard-static-dlopen-mod.so $L/tst-ptrguard-static-dlopen-mod.so
@@ -0,0 +1,6 @@
+# defines target $(gen-gconv-modules) that ensures gconv-modules are available
+
+gen-gconv-modules := $(common-objpfx)iconvdata/gconv-modules
+
+$(gen-gconv-modules):
+	$(MAKE) -C ../iconvdata subdir=iconvdata $@
@@ -39,8 +39,8 @@ struct protoent_data {};
 #include <nss/nss_files/files-parse.c>
 LINE_PARSER
 ("#",
- STRING_FIELD (result->p_name, isspace, 1);
- INT_FIELD (result->p_proto, isspace, 1, 10,);
+ STRING_FIELD (result->p_name, isspace, true);
+ INT_FIELD (result->p_proto, isspace, true, 10,);
 )

 enum nss_status
@@ -39,9 +39,9 @@ struct servent_data {};
 #define ISSC_OR_SPACE(c)	((c) ==  ';' || isspace (c))
 LINE_PARSER
 ("#",
- STRING_FIELD (result->s_name, ISSC_OR_SPACE, 1);
- STRING_FIELD (result->s_proto, ISSC_OR_SPACE, 1);
- INT_FIELD (result->s_port, ISSC_OR_SPACE, 10, 0, htons);
+ STRING_FIELD (result->s_name, ISSC_OR_SPACE, true);
+ STRING_FIELD (result->s_proto, ISSC_OR_SPACE, true);
+ INT_FIELD (result->s_port, ISSC_OR_SPACE, false, 10, htons);
 )

 enum nss_status
@@ -139,7 +139,8 @@ $(objpfx)test-iconvconfig.out: $(objpfx)iconvconfig
 	 rm -f $$tmp) > $@; \
 	$(evaluate-test)

-$(objpfx)tst-iconv_prog.out: tst-iconv_prog.sh $(objpfx)iconv_prog
+$(objpfx)tst-iconv_prog.out: tst-iconv_prog.sh $(objpfx)iconv_prog \
+  $(gen-locales)
 	$(BASH) $< $(common-objdir) '$(test-wrapper-env)' \
 		 '$(run-program-env)' '$(rpath-link)' > $@; \
 	$(evaluate-test)
@@ -144,8 +144,10 @@
    if (irreversible == NULL)						      \
      {									      \
 	/* This means we are in call from __gconv_transliterate.  In this     \
-	   case we are not doing any error recovery ourselves.  */	      \
-	result = __gconv_mark_illegal_input (step_data);		      \
+	   case we are not doing any error recovery ourselves.  Do not create \
+	   a persistent error state.  If __gconv_transliterate exhausts all   \
+	   alternatives, it will call __gconv_mark_illegal_input itself.  */  \
+	result = __GCONV_ILLEGAL_INPUT;					      \
 	break;								      \
      }									      \
 									      \
@@ -29,10 +29,10 @@ LIBPATH=$codir:$codir/iconvdata

 # How the start the iconv(1) program.  $from is not defined/expanded yet.
 ICONV='
+$test_wrapper_env $run_program_env
 $codir/elf/ld.so --library-path $library_path:$LIBPATH --inhibit-rpath ${from}.so
 $codir/iconv/iconv_prog
 '
-ICONV="$test_wrapper_env $run_program_env $ICONV"

 TIMEOUTFACTOR=${TIMEOUTFACTOR:-1}

@@ -220,6 +220,7 @@ testarray=(
 "\x00\x00;;INVALID;UTF-8;1"
 "\x00\x00;;UTF-8;INVALID;1"
 "\xc3\xa9;;UTF-8;ASCII//TRANSLIT;0"
+"X\xc2\xbdY;;UTF-8;ASCII//TRANSLIT;0"
 )

 # Requires $twobyte input, $c flag, $from, and $to to be set; sets $ret
@@ -280,12 +281,21 @@ check_errtest_result ()
  fi
 }

-for testcommand in "${testarray[@]}"; do
-  twobyte="$(echo "$testcommand" | cut -d";" -f 1)"
-  c="$(echo "$testcommand" | cut -d";" -f 2)"
-  from="$(echo "$testcommand" | cut -d";" -f 3)"
-  to="$(echo "$testcommand" | cut -d";" -f 4)"
-  eret="$(echo "$testcommand" | cut -d";" -f 5)"
-  execute_test
-  check_errtest_result
-done
+run_test_array ()
+{
+  for testcommand in "${testarray[@]}"; do
+    twobyte="$(echo "$testcommand" | cut -d";" -f 1)"
+    c="$(echo "$testcommand" | cut -d";" -f 2)"
+    from="$(echo "$testcommand" | cut -d";" -f 3)"
+    to="$(echo "$testcommand" | cut -d";" -f 4)"
+    eret="$(echo "$testcommand" | cut -d";" -f 5)"
+    execute_test
+    check_errtest_result
+  done
+}
+
+echo "info: testing C locale"
+run_test_array
+echo "info: testing en_US.UTF-8 locale"
+run_program_env="$run_program_env LC_ALL=en_US.UTF-8"
+run_test_array
@@ -671,7 +671,7 @@ for linking")

 /* Helper / base  macros for indirect function symbols.  */
 #define __ifunc_resolver(type_name, name, expr, init, classifier, ...)	\
-  classifier inhibit_stack_protector					\
+  classifier								\
  __typeof (type_name) *name##_ifunc (__VA_ARGS__)			\
  {									\
    init ();								\
@@ -70,6 +70,11 @@ libc_hidden_proto (__libc_res_nameinquery)
 extern __typeof (__res_queriesmatch) __libc_res_queriesmatch;
 libc_hidden_proto (__libc_res_queriesmatch)

+extern const struct res_sym __p_class_syms[];
+libresolv_hidden_proto (__p_class_syms)
+extern const struct res_sym __p_type_syms[];
+libresolv_hidden_proto (__p_type_syms)
+
 /* Variant of res_hnok which operates on binary (but uncompressed) names.  */
 bool __res_binary_hnok (const unsigned char *dn) attribute_hidden;

@@ -134,10 +134,6 @@ endif
 $(inst_sysconfdir)/rpc: etc.rpc $(+force)
 	$(do-install)

-ifeq ($(build-static-nss),yes)
-CFLAGS += -DSTATIC_NSS
-endif
-
 ifeq ($(have-test-clang),yes)
 CFLAGS-tst-deadline.c += -Wno-ignored-attributes
 endif
@@ -270,7 +270,7 @@ __wunderflow (FILE *fp)
      if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))
 	return WEOF;
    }
-  else if (_IO_have_backup (fp))
+  else if (_IO_have_wbackup (fp))
    _IO_free_wbackup_area (fp);
  return _IO_UNDERFLOW (fp);
 }
@@ -603,6 +603,6 @@ _IO_unsave_wmarkers (FILE *fp)
      fp->_markers = NULL;
    }

-  if (_IO_have_backup (fp))
+  if (_IO_have_wbackup (fp))
    _IO_free_wbackup_area (fp);
 }
@@ -287,7 +287,7 @@ install-others := $(addprefix $(inst_i18ndir)/, \
 			      $(locales))
 endif

-tests: $(objdir)/iconvdata/gconv-modules
+tests: $(gen-gconv-modules)

 tests-static += \
  tst-langinfo-newlocale-static \
@@ -412,6 +412,7 @@ LOCALES := \
  # LOCALES

 include ../gen-locales.mk
+include ../gen-gconv-modules.mk

 $(objpfx)tst-iconv-emojis-trans.out: $(gen-locales)

@@ -587,6 +588,3 @@ $(objpfx)mtrace-tst-leaks.out: $(objpfx)tst-leaks.out

 bug-setlocale1-ENV-only = LOCPATH=$(objpfx) LC_CTYPE=de_DE.UTF-8
 bug-setlocale1-static-ENV-only = $(bug-setlocale1-ENV-only)
-
-$(objdir)/iconvdata/gconv-modules:
-	$(MAKE) -C ../iconvdata subdir=iconvdata $@
@@ -252,20 +252,6 @@ __ptmalloc_init (void)
  tcache_key_initialize ();
 #endif

-#ifdef USE_MTAG
-  if ((TUNABLE_GET_FULL (glibc, mem, tagging, int32_t, NULL) & 1) != 0)
-    {
-      /* If the tunable says that we should be using tagged memory
-	 and that morecore does not support tagged regions, then
-	 disable it.  */
-      if (__MTAG_SBRK_UNTAGGED)
-	__always_fail_morecore = true;
-
-      mtag_enabled = true;
-      mtag_mmap_flags = __MTAG_MMAP_FLAGS;
-    }
-#endif
-
 #if defined SHARED && IS_IN (libc)
  /* In case this libc copy is in a non-default namespace, never use
     brk.  Likewise if dlopened from statically linked program.  The
@@ -417,7 +403,7 @@ alloc_new_heap  (size_t size, size_t top_pad, size_t pagesize,
            }
        }
    }
-  if (__mprotect (p2, size, mtag_mmap_flags | PROT_READ | PROT_WRITE) != 0)
+  if (__mprotect (p2, size, extra_mmap_prot | PROT_READ | PROT_WRITE) != 0)
    {
      __munmap (p2, max_size);
      return NULL;
@@ -471,7 +457,7 @@ grow_heap (heap_info *h, long diff)
    {
      if (__mprotect ((char *) h + h->mprotect_size,
                      (unsigned long) new_size - h->mprotect_size,
-                      mtag_mmap_flags | PROT_READ | PROT_WRITE) != 0)
+                      extra_mmap_prot | PROT_READ | PROT_WRITE) != 0)
        return -2;

      h->mprotect_size = new_size;
@@ -813,16 +799,11 @@ arena_get2 (size_t size, mstate avoid_arena)
        {
          if (mp_.arena_max != 0)
            narenas_limit = mp_.arena_max;
-          else if (narenas > mp_.arena_test)
+          else if (narenas >= mp_.arena_test)
            {
-              int n = __get_nprocs ();
-
-              if (n >= 1)
-                narenas_limit = NARENAS_FROM_NCORES (n);
-              else
-                /* We have no information about the system.  Assume two
-                   cores.  */
-                narenas_limit = NARENAS_FROM_NCORES (2);
+	      narenas_limit = __get_nprocs ();
+	      if (narenas_limit < mp_.arena_test)
+		narenas_limit = mp_.arena_test;
            }
        }
    repeat:;
@@ -19,12 +19,8 @@
 #define __mremap mremap
 #include "malloc.c"

-/* When memory is tagged, the checking data is stored in the user part
-   of the chunk.  We can't rely on the user not having modified the
-   tags, so fetch the tag at each location before dereferencing
-   it.  */
-#define SAFE_CHAR_OFFSET(p,offset) \
-  ((unsigned char *) tag_at (((unsigned char *) p) + offset))
+#define CHAR_OFFSET(p,offset) \
+  ((unsigned char *) (((unsigned char *) p) + offset))

 /* A simple, standard set of debugging hooks.  Overhead is `only' one
   byte per chunk; still this will catch most cases of double frees or
@@ -58,7 +54,7 @@ malloc_check_get_size (void *mem)
  unsigned char magic = magicbyte (p);

  for (size = CHUNK_HDR_SZ + memsize (p) - 1;
-       (c = *SAFE_CHAR_OFFSET (p, size)) != magic;
+       (c = *CHAR_OFFSET (p, size)) != magic;
       size -= c)
    {
      if (c <= 0 || size < (c + CHUNK_HDR_SZ))
@@ -95,9 +91,9 @@ mem2mem_check (void *ptr, size_t req_sz)
      if (block_sz == magic)
        --block_sz;

-      *SAFE_CHAR_OFFSET (m_ptr, i) = block_sz;
+      *CHAR_OFFSET (m_ptr, i) = block_sz;
    }
-  *SAFE_CHAR_OFFSET (m_ptr, req_sz) = magic;
+  *CHAR_OFFSET (m_ptr, req_sz) = magic;
  return (void *) m_ptr;
 }

@@ -131,7 +127,7 @@ mem2chunk_check (void *mem, unsigned char **magic_p)
        return NULL;

      for (sz = CHUNK_HDR_SZ + memsize (p) - 1;
-	   (c = *SAFE_CHAR_OFFSET (p, sz)) != magic;
+	   (c = *CHAR_OFFSET (p, sz)) != magic;
 	   sz -= c)
        {
          if (c == 0 || sz < (c + CHUNK_HDR_SZ))
@@ -156,7 +152,7 @@ mem2chunk_check (void *mem, unsigned char **magic_p)
        return NULL;

      for (sz = CHUNK_HDR_SZ + memsize (p) - 1;
-	   (c = *SAFE_CHAR_OFFSET (p, sz)) != magic;
+	   (c = *CHAR_OFFSET (p, sz)) != magic;
 	   sz -= c)
        {
          if (c == 0 || sz < (c + CHUNK_HDR_SZ))
@@ -164,7 +160,7 @@ mem2chunk_check (void *mem, unsigned char **magic_p)
        }
    }

-  unsigned char* safe_p = SAFE_CHAR_OFFSET (p, sz);
+  unsigned char* safe_p = CHAR_OFFSET (p, sz);
  *safe_p ^= 0xFF;
  if (magic_p)
    *magic_p = safe_p;
@@ -204,7 +200,7 @@ malloc_check (size_t sz)
  top_check ();
  victim = _int_malloc (&main_arena, nb);
  __libc_lock_unlock (main_arena.mutex);
-  return mem2mem_check (tag_new_usable (victim), sz);
+  return mem2mem_check (victim, sz);
 }

 static void
@@ -217,11 +213,6 @@ free_check (void *mem)

  int err = errno;

-  /* Quickly check that the freed pointer matches the tag for the memory.
-     This gives a useful double-free detection.  */
-  if (__glibc_unlikely (mtag_enabled))
-    *(volatile char *)mem;
-
  __libc_lock_lock (main_arena.mutex);
  p = mem2chunk_check (mem, NULL);
  if (!p)
@@ -233,9 +224,7 @@ free_check (void *mem)
    }
  else
    {
-      /* Mark the chunk as belonging to the library again.  */
-      (void)tag_region (chunk2mem (p), memsize (p));
-      _int_free_chunk (&main_arena, p, chunksize (p), 1);
+      _int_free_merge_chunk (&main_arena, p, chunksize (p));
      __libc_lock_unlock (main_arena.mutex);
    }
  __set_errno (err);
@@ -263,11 +252,6 @@ realloc_check (void *oldmem, size_t bytes)
      return NULL;
    }

-  /* Quickly check that the freed pointer matches the tag for the memory.
-     This gives a useful double-free detection.  */
-  if (__glibc_unlikely (mtag_enabled))
-    *(volatile char *)oldmem;
-
  __libc_lock_lock (main_arena.mutex);
  const mchunkptr oldp = mem2chunk_check (oldmem, &magic_p);
  __libc_lock_unlock (main_arena.mutex);
@@ -288,7 +272,7 @@ realloc_check (void *oldmem, size_t bytes)
 #if HAVE_MREMAP
      mchunkptr newp = mremap_chunk (oldp, chnb);
      if (newp)
-        newmem = chunk2mem_tag (newp);
+        newmem = chunk2mem (newp);
      else
 #endif
      {
@@ -323,7 +307,7 @@ invert:

  __libc_lock_unlock (main_arena.mutex);

-  return mem2mem_check (tag_new_usable (newmem), bytes);
+  return mem2mem_check (newmem, bytes);
 }

 static void *
@@ -365,7 +349,7 @@ memalign_check (size_t alignment, size_t bytes)
  top_check ();
  mem = _int_memalign (&main_arena, alignment, bytes + 1);
  __libc_lock_unlock (main_arena.mutex);
-  return mem2mem_check (tag_new_usable (mem), bytes);
+  return mem2mem_check (mem, bytes);
 }

 static void
@@ -24,6 +24,8 @@
 #include <malloc-size.h>
 #include <hugepages.h>
 #include <calloc-clear-memory.h>
+#include <malloc-api.h>
+#include <malloc-ifuncs.h>

 /* Called in the parent process before a fork.  */
 void __malloc_fork_lock_parent (void) attribute_hidden;
@@ -310,7 +310,7 @@ int
 do_test (void)
 {
  /* Limit the number of malloc arenas.  We use a very low number so
-     that despute the address space limit configured below, all
+     that despite the address space limit configured below, all
     requested arenas a can be created.  */
  if (mallopt (M_ARENA_MAX, 2) == 0)
    {
@@ -1842,7 +1842,8 @@ two things: either all bytes from the input buffer are consumed or
 there are some bytes at the end of the buffer that possibly can form a
 complete character but the input is incomplete.  The second reason for a
 stop is that the output buffer is full.  And the third reason is that
-the input contains invalid characters.
+the input contains invalid characters or translation to the character
+encoding of the output is not possible.

 In all of these cases the buffer pointers after the last successful
 conversion, for the input and output buffers, are stored in @var{inbuf} and
@@ -1866,9 +1867,11 @@ the value pointed to by @var{inbytesleft} is nonzero.

@table @code
@item EILSEQ
-The conversion stopped because of an invalid byte sequence in the input.
+The conversion stopped because of an invalid byte sequence in the
+input or because translation of the byte sequence to the character
+encoding of the output is not possible.
 After the call, @code{*@var{inbuf}} points at the first byte of the
-invalid byte sequence.
+byte sequence which caused the error.

@item E2BIG
 The conversion stopped because it ran out of space in the output buffer.
@@ -17,6 +17,7 @@ Dynamic linkers are sometimes called @dfn{dynamic loaders}.
 * Dynamic Linker Environment Variables:: Environment variables that control the
                                          dynamic linker.
 * Dynamic Linker Introspection::    Interfaces for querying mapping information.
+* Indirect Functions::          Selecting function implementations at load time.
 * Dynamic Linker Hardening::    Avoiding unexpected issues with dynamic linking.
@end menu

@@ -735,6 +736,299 @@ A bit mask used to signal that the object contains SFrame data.  See

@end table

+@node Indirect Functions
+@section Indirect Functions
+@cindex indirect function
+@cindex IFUNC
+@cindex @code{STT_GNU_IFUNC}
+@cindex resolver function (IFUNC)
+
+@dfn{Indirect functions} (often called @dfn{IFUNCs}) are a GNU
+extension to ELF that defers the selection of a function
+implementation until load time.  A symbol of type
+@code{STT_GNU_IFUNC} does not designate the implementation of a
+function.  Instead, it designates a @dfn{resolver function}.
+@Theglibc{} invokes the resolver while processing relocations that
+reference the symbol, and the address returned by the resolver becomes
+the target of those references.  The typical use of indirect functions
+is to select the variant of a function best suited to the system the
+program is running on, for example based on the available instruction
+set extensions.
+
+Indirect functions are usually defined using the @code{ifunc} function
+attribute provided by GCC and compatible compilers:
+
+@smallexample
+static int
+my_func_generic (int a)
+@{
+  /* @r{@dots{}} */
+@}
+
+static int
+my_func_vectorized (int a)
+@{
+  /* @r{@dots{}} */
+@}
+
+/* @r{The resolver returns the address of the selected
+   implementation.}  */
+static typeof (my_func_generic) *
+my_func_resolver (void)
+@{
+  if (vector_extension_available ())
+    return my_func_vectorized;
+  return my_func_generic;
+@}
+
+int my_func (int a) __attribute__ ((ifunc ("my_func_resolver")));
+@end smallexample
+
+@subsection IFUNC Resolver Calling Conventions
+
+The return value is the address of the selected implementation.
+On many architectures, the resolver receives arguments that describe
+the capabilities of the system, typically derived from the @code{AT_HWCAP}
+value in the auxiliary vector (@pxref{Auxiliary Vector}).  These arguments
+exist because of the restricted environment resolvers run in (see below):
+they allow a resolver to select an implementation without having to obtain
+the information through other means.  Where such arguments are available,
+resolvers should use them instead of querying the system through
+function calls.
+
+The architecture-specific conventions are:
+
+@table @asis
+@item AArch64
+@smallexample
+#include <sys/ifunc.h>
+
+void *resolver (uint64_t hwcap, const __ifunc_arg_t *arg);
+@end smallexample
+
+The first argument contains the @code{AT_HWCAP} value.  If the
+@code{_IFUNC_ARG_HWCAP} bit is set, the second argument is valid and
+points to a @code{__ifunc_arg_t} structure that provides access to all
+hardware capability values: the @code{_size} member contains the size of
+the structure in bytes, and the @code{_hwcap}, @code{_hwcap2},
+@code{_hwcap3}, and @code{_hwcap4} members contain the
+@code{AT_HWCAP}, @code{AT_HWCAP2}, @code{AT_HWCAP3}, and
+@code{AT_HWCAP4} values, respectively.  Resolvers must check
+@code{_size} before accessing a member, because @theglibc{} may pass
+a structure that ends before that member.  The @code{__ifunc_hwcap}
+inline function in @file{sys/ifunc.h} performs the required checks
+when obtaining a hardware capability value by index.
+
+The canonical documentation for this interface is the
+@cite{GNU C Library ifunc interface} section of the @cite{ELF for the
+Arm 64-bit Architecture (AArch64)} ABI, available at
+@uref{https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst}.
+
+@item Arm
+@smallexample
+void *resolver (unsigned long int hwcap);
+@end smallexample
+
+The argument contains the @code{AT_HWCAP} value.
+
+@item LoongArch
+@smallexample
+#include <sys/ifunc.h>
+
+void *resolver (const __ifunc_arg_t *arg);
+@end smallexample
+
+The argument points to a @code{__ifunc_arg_t} structure whose
+@code{_size} member contains the size of the structure in bytes and
+whose @code{_hwcap} member contains the @code{AT_HWCAP} value.  Resolvers
+must check @code{_size} before accessing members added by later versions
+of the structure.
+
+@item PowerPC (32-bit and 64-bit)
+@smallexample
+void *resolver (unsigned long int hwcap);
+@end smallexample
+
+The argument contains the @code{AT_HWCAP} value.  The
+@code{AT_HWCAP2} value is not passed as an argument.
+
+@item RISC-V
+@smallexample
+#include <sys/hwprobe.h>
+
+void *resolver (uint64_t hwcap, __riscv_hwprobe_t hwprobe,
+                void *reserved);
+@end smallexample
+
+The first argument contains the @code{AT_HWCAP} value.  The second
+argument is a pointer to the @code{__riscv_hwprobe} function
+(@pxref{RISC-V}), passed so that the resolver can probe for extensions
+without referencing a symbol in another object.  Versions of
+@theglibc{} before 2.40 pass a null pointer here, so resolvers must
+check the argument before calling it; the @code{__riscv_hwprobe_one}
+inline function in @file{sys/hwprobe.h} performs this check.  The
+third argument is reserved for future extension.
+
+@item s390 (64-bit)
+@smallexample
+void *resolver (unsigned long int hwcap);
+@end smallexample
+
+The argument contains the @code{AT_HWCAP} value.
+
+@item SPARC (32-bit and 64-bit)
+@smallexample
+void *resolver (int hwcap);
+@end smallexample
+
+The argument contains the @code{AT_HWCAP} value.
+
+@item x86 (i386 and x86-64)
+@smallexample
+void *resolver (void);
+@end smallexample
+
+No arguments are passed: on x86 the @code{CPUID} instruction can be
+executed directly from the resolver instead.  Resolvers can use the
+@code{__cpuid} and @code{__cpuid_count} macros from the GCC
+@file{cpuid.h} header.
+
+Alternatively, the @code{CPU_FEATURE_PRESENT} and
+@code{CPU_FEATURE_ACTIVE} macros from @file{sys/platform/x86.h}
+(@pxref{X86}) can be used; the data they consult is initialized by
+@theglibc{} before any resolver runs.
+@end table
+
+@subsection When IFUNC Resolvers Run
+
+Resolver functions run early, before the process or the newly loaded
+objects are fully initialized.  The exact point at which a resolver
+runs depends on how the indirect function is referenced and how the
+program is linked:
+
+@itemize @bullet
+@item
+In dynamically linked programs, resolvers for non-lazy references run
+during relocation processing at program startup, before ELF
+constructors and before @code{main}.  Non-lazy references include data
+relocations against the function address (for example, initialized
+function pointer variables), and all references if lazy binding is
+disabled (for example, with the @option{-z now} link-time option or
+the @env{LD_BIND_NOW} environment variable).
+
+@item
+With lazy binding, the resolver for a function call through the PLT
+may not run until the function is called for the first time.  Programs
+should not depend on whether a resolver runs at load time or at the
+time of the first call.
+
+@item
+For objects loaded with @code{dlopen}, resolvers run during the
+relocation of the newly loaded objects, before their ELF constructors
+run.
+
+@item
+In statically linked programs (including static PIE), resolvers are
+invoked by the startup code in @theglibc{}, before ELF constructors
+and before @code{main}.
+@end itemize
+
+A resolver can be invoked more than once: in general, it runs once for
+every relocation that references the indirect function symbol, and
+distinct objects referencing the same symbol cause separate resolver
+invocations.  Under lazy binding, resolver invocations can also happen
+concurrently on multiple threads.  Resolvers must therefore be
+idempotent: they should return the same implementation on every
+invocation and avoid side effects.
+
+@subsection Supported Functionality in IFUNC Resolvers
+
+Because resolvers run during relocation processing, only a restricted
+execution environment is available to them.  @Theglibc{} provides the
+guarantees listed below, each annotated with the version of @theglibc{}
+from which it applies.  Versions before 2.44 provided none of them:
+resolvers could run before thread-local storage, the TCB, and the stack
+protector were initialized, and before the relocations of other objects
+had been processed.  A resolver that must remain compatible with those
+versions should not rely on any of these guarantees, and should restrict
+itself to the architecture-provided resolver arguments and to data
+defined in the same translation unit.
+
+@itemize @bullet
+@item
+The thread control block (TCB) of the initial thread is set up before
+any resolver runs.  This applies to dynamically linked programs and to
+statically linked programs (including static PIE).  Consequently,
+resolvers may be compiled with stack protector instrumentation
+(@option{-fstack-protector} and its variants): the stack canary is
+initialized before the first resolver runs.  (Since @theglibc{} 2.44.)
+
+@item
+Tunables (@pxref{Tunables}) and the architecture-specific CPU feature
+detection used by @theglibc{} are processed before any resolver runs.
+A resolver that selects an implementation based on @theglibc{}'s CPU
+feature data therefore observes values that already reflect any tunable
+that masks hardware capabilities, such as @code{glibc.cpu.hwcaps}
+(@pxref{Hardware Capability Tunables}).  (Since @theglibc{} 2.44.)
+
+@item
+A resolver may read from and write to thread-local variables
+(@code{__thread}, @code{_Thread_local}) defined by the same object
+that defines the resolver, using any TLS access model.  The initial
+values of such variables are visible to the resolver, and stores
+performed by the resolver persist after it returns.  This applies to
+objects loaded at process startup, to objects loaded with
+@code{dlopen}, and to statically linked programs.  (Since @theglibc{}
+2.44.)
+
+@item
+At program startup, the regular (non-IFUNC) relocations of all
+initially loaded objects are processed before any resolver runs.  A
+resolver may therefore reference data and call functions defined in
+other initially loaded objects.  (Since @theglibc{} 2.44.)
+
+@item
+During @code{dlopen}, newly loaded objects are relocated after their
+dependencies.  A resolver in a newly loaded object may reference data
+and call functions defined by the object itself, by its dependencies
+(direct and indirect), and by objects that were already loaded before
+the @code{dlopen} call.  (Since @theglibc{} 2.44.)
+@end itemize
+
+@Theglibc{} itself defines indirect functions and the guarantees above
+apply to these internal resolvers as well.
+
+Everything not listed above should be considered unsupported.  In
+particular, the following restrictions apply:
+
+@itemize @bullet
+@item
+ELF constructors of the objects being loaded have not run when their
+resolvers are invoked.  Resolvers must not depend on any initialization
+performed by constructors, such as the construction of C++ global objects,
+even in other objects whose relocations have already been processed.
+
+@item
+Accessing thread-local variables defined by other objects is not
+supported.
+
+@item
+Functions that depend on a fully initialized @theglibc{}, or that may
+call back into the dynamic linker, are not supported in resolvers.
+This includes (but is not limited to) @code{malloc}, @code{dlopen},
+@code{dlsym}, and creating threads.
+
+@item
+Because a resolved address is bound permanently, resolvers must not
+base their decision on state that can change during the lifetime of
+the process (@pxref{Single-Threaded, , Detecting Single-Threaded
+Execution}, for an example involving
+@code{__libc_single_threaded}).
+@end itemize
+
+For recommendations on the use of indirect functions in hardened or
+security-sensitive applications, @pxref{Dynamic Linker Hardening}.
+
@node Dynamic Linker Hardening
@section Avoiding Unexpected Issues With Dynamic Linking

@@ -828,9 +1122,12 @@ Underlinking (see above) can hide the presence of cycles.

@item
 Limit the creation of indirect function (IFUNC) resolvers.  These
-resolvers run during relocation processing, when @theglibc{} is not in
-a fully consistent state.  If you write your own IFUNC resolvers, do
-not depend on external data or function references in those resolvers.
+resolvers run during relocation processing, before the process or the
+newly loaded objects are fully initialized
+(@pxref{Indirect Functions}).  If you write your own IFUNC resolvers,
+keep them self-contained: do not depend on external data or function
+references in those resolvers, even where current versions of
+@theglibc{} support such references.

@item
 Do not use the audit functionality (@code{LD_AUDIT}, @code{DT_AUDIT},
@@ -185,29 +185,10 @@ non CET enabled shared library in CET enabled application.

 NOTE: @option{--enable-cet} is only supported on x86_64 and x32.

-@item --enable-memory-tagging
-Enable memory tagging support if the architecture supports it.  When
-@theglibc{} is built with this option then the resulting library will
-be able to control the use of tagged memory when hardware support is
-present by use of the tunable @samp{glibc.mem.tagging}.  This includes
-the generation of tagged memory when using the @code{malloc} APIs.
-
-At present only AArch64 platforms with MTE provide this functionality,
-although the library will still operate (without memory tagging) on
-older versions of the architecture.
-
-The default is to disable support for memory tagging.
-
@item --disable-profile
 Don't build libraries with profiling information.  You may want to use
 this option if you don't plan to do profiling.

-@item --enable-static-nss
-Compile static versions of the NSS (Name Service Switch) libraries.
-This is not recommended because it defeats the purpose of NSS; a program
-linked statically with the NSS libraries cannot be dynamically
-reconfigured to use a different name database.
-
@item --enable-hardcoded-path-in-tests
 By default, dynamic tests are linked to run with the installed C library.
 This option hardcodes the newly built C library path in dynamic tests
@@ -2863,7 +2863,6 @@ aiocb64}, since the LFS transparently replaces the old interface.
@c     _dl_deallocate_tls dup
@c     munmap ok
@c    THREAD_COPY_STACK_GUARD ok
-@c    THREAD_COPY_POINTER_GUARD ok
@c    atomic_exchange_acquire ok
@c    lll_futex_wake ok
@c    deallocate_stack @asulock @ascuheap @aculock @acsmem
@@ -1388,11 +1388,8 @@ environment variable @env{MALLOC_ARENA_TEST} to the desired value.
 This parameter sets the number of arenas to use regardless of the number of
 cores in the system.

-The default value of this tunable is @code{0}, meaning that the limit on the
-number of arenas is determined by the number of CPU cores online. For 32-bit
-systems the limit is twice the number of cores online and on 64-bit systems, it
-is eight times the number of cores online.  Note that the default value is not
-derived from the default value of M_ARENA_TEST and is computed independently.
+The default value of this tunable is @code{0}, meaning that the limit is the
+number of CPU cores online reported by get_nprocs().

 This parameter can also be set for the process at startup by setting the
 environment variable @env{MALLOC_ARENA_MAX} to the desired value.
@@ -1803,6 +1803,12 @@ to an @code{unsigned char}) in the initial @var{size} bytes of the
 object beginning at @var{block}.  The return value is a pointer to the
 located byte, or a null pointer if no match was found.

+This function behaves as if it reads the bytes sequentially and stops at
+the first match, which means that if the object contains a match the
+behavior is defined even when the object size is less than @var{size}.
+This behavior guarantee is unusual, and is not shared by related
+functions like @code{memcmp} and @code{wmemchr}.
+
 In ISO C23 and later, this function is qualifier-generic:
 that is, it is also implemented as a function-like macro,
 and when the macro is used and @var{block} has a type
@@ -40,7 +40,6 @@ glibc.malloc.perturb: 0 (min: 0, max: 255)
 glibc.cpu.x86_shared_cache_size: 0x100000 (min: 0x0, max: 0xffffffffffffffff)
 glibc.pthread.rseq: 1 (min: 0, max: 1)
 glibc.cpu.prefer_map_32bit_exec: 0 (min: 0, max: 1)
-glibc.mem.tagging: 0 (min: 0, max: 255)
 glibc.malloc.hugetlb: 0x0 (min: 0x0, max: 0xffffffffffffffff)
 glibc.cpu.x86_rep_movsb_threshold: 0x2000 (min: 0x100, max: 0xffffffffffffffff)
 glibc.malloc.mxfast: 0x0 (min: 0x0, max: 0xffffffffffffffff)
@@ -221,10 +220,8 @@ identical in features.
 This tunable sets the number of arenas to use in a process regardless of the
 number of cores in the system.

-The default value of this tunable is @code{0}, meaning that the limit on the
-number of arenas is determined by the number of CPU cores online.  For 32-bit
-systems the limit is twice the number of cores online and on 64-bit systems, it
-is 8 times the number of cores online.
+The default value of this tunable is @code{0}, meaning that the limit is the
+number of CPU cores online reported by get_nprocs().
@end deftp

@deftp Tunable glibc.malloc.tcache_max
@@ -240,31 +237,27 @@ disabled.

 The approximate maximum overhead of the per-thread cache is thus equal
 to the number of bins times the chunk count in each bin times the size
-of each chunk.  With defaults, the approximate maximum overhead of the
-per-thread cache is approximately 236 KB on 64-bit systems and 118 KB
-on 32-bit systems.
+of each chunk.
@end deftp

@deftp Tunable glibc.malloc.mxfast
-One of the optimizations @code{malloc} uses is to maintain a series of ``fast
-bins'' that hold chunks up to a specific size.  The default and
-maximum size which may be held this way is 80 bytes on 32-bit systems
-or 160 bytes on 64-bit systems.  Applications which value size over
-speed may choose to reduce the size of requests which are serviced
-from fast bins with this tunable.  Note that the value specified
-includes @code{malloc}'s internal overhead, which is normally the size of one
-pointer, so add 4 on 32-bit systems or 8 on 64-bit systems to the size
-passed to @code{malloc} for the largest bin size to enable.
+This tunable has no effect since the ``fastbins'' have been removed.
@end deftp

@deftp Tunable glibc.malloc.hugetlb
 This tunable controls the usage of Huge Pages on @code{malloc} calls.  The
-default value is @code{0}, which disables any additional support on
-@code{malloc}.
+default value is @code{0} on most targets.  Using @code{0} disables support
+that improves use of huge pages in @code{malloc}.  However huge pages may
+still be created depending on the OS settings.

 Setting its value to @code{1} enables the use of @code{madvise} with
@code{MADV_HUGEPAGE} after memory allocation with @code{mmap}.  It is enabled
 only if the system supports Transparent Huge Page (currently only on Linux).
+This is the default used for AArch64.
+
+When @code{glibc.elf.thp} set to 1, malloc uses the actual kernel THP mode
+instead of defaulting to madvise mode and madvise_thp will stop issuing
+MADV_HUGEPAGE if kernel THP mode is always.

 Setting its value to @code{2} enables the use of Huge Page directly with
@code{mmap} with the use of @code{MAP_HUGETLB} flag.  The huge page size
@@ -666,34 +659,6 @@ This tunable namespace supports operations that affect the way @theglibc{}
 and the process manage memory.
@end deftp

-@deftp Tunable glibc.mem.tagging
-If the hardware supports memory tagging, this tunable can be used to
-control the way @theglibc{} uses this feature.  At present this is only
-supported on AArch64 systems with the MTE extension; it is ignored for
-all other systems.
-
-This tunable takes a value between 0 and 255 and acts as a bitmask
-that enables various capabilities.
-
-Bit 0 (the least significant bit) causes the @code{malloc}
-subsystem to allocate
-tagged memory, with each allocation being assigned a random tag.
-
-Bit 1 enables precise faulting mode for tag violations on systems that
-support deferred tag violation reporting.  This may cause programs
-to run more slowly.
-
-Bit 2 enables either precise or deferred faulting mode for tag violations
-whichever is preferred by the system.
-
-Other bits are currently reserved.
-
-@Theglibc{} startup code will automatically enable memory tagging
-support in the kernel if this tunable has any non-zero value.
-
-The default value is @samp{0}, which disables all memory tagging.
-@end deftp
-
@deftp Tunable glibc.mem.decorate_maps
 If the kernel supports naming anonymous virtual memory areas (since
 Linux version 5.17, although not always enabled by some kernel
@@ -236,6 +236,19 @@ acosh 0x1.00b3140f6b582p+0
 acosh 0x1.00b31560e5422p+0
 acosh 0x1.00b3156dfbb59p+0
 acosh 0x1.00b319a514ad9p+0
+acosh 0x1.004292b93a05ep+0
+acosh 0x1.0042d6fc11ef6p+0
+acosh 0x1.00a7deb3381abp+0
+acosh 0x1.00a7ff291046ap+0
+acosh 0x1.00a800422847ap+0
+acosh 0x1.00a8178044ea8p+0
+acosh 0x1.00a83624f0d22p+0
+acosh 0x1.00a851f655836p+0
+acosh 0x1.00a86ce6bcfb9p+0
+acosh 0x1.00a888136de79p+0
+acosh 0x1.00a8abbf7ef1ap+0
+acosh 0x1.1p+1
+acosh 0x1.3bf8009648dcp+16
 acosh max

 add 0 0
@@ -3041,6 +3041,859 @@ acosh 0x1.00b319a514ad9p+0
 = acosh tonearest ibm128 0x1.00b319a514ad9p+0 : 0x1.2ebfff0249e40ffff0d22dedd18p-4 : inexact-ok
 = acosh towardzero ibm128 0x1.00b319a514ad9p+0 : 0x1.2ebfff0249e40ffff0d22dedd18p-4 : inexact-ok
 = acosh upward ibm128 0x1.00b319a514ad9p+0 : 0x1.2ebfff0249e40ffff0d22dedd2p-4 : inexact-ok
+acosh 0x1.004292b93a05ep+0
+= acosh downward binary32 0x1.004294p+0 : 0xb.89d1dp-8 : inexact-ok
+= acosh tonearest binary32 0x1.004294p+0 : 0xb.89d1ep-8 : inexact-ok
+= acosh towardzero binary32 0x1.004294p+0 : 0xb.89d1dp-8 : inexact-ok
+= acosh upward binary32 0x1.004294p+0 : 0xb.89d1ep-8 : inexact-ok
+= acosh downward binary64 0x1.004294p+0 : 0xb.89d1d8345ccbp-8 : inexact-ok
+= acosh tonearest binary64 0x1.004294p+0 : 0xb.89d1d8345ccbp-8 : inexact-ok
+= acosh towardzero binary64 0x1.004294p+0 : 0xb.89d1d8345ccbp-8 : inexact-ok
+= acosh upward binary64 0x1.004294p+0 : 0xb.89d1d8345ccb8p-8 : inexact-ok
+= acosh downward intel96 0x1.004294p+0 : 0xb.89d1d8345ccb064p-8 : inexact-ok
+= acosh tonearest intel96 0x1.004294p+0 : 0xb.89d1d8345ccb065p-8 : inexact-ok
+= acosh towardzero intel96 0x1.004294p+0 : 0xb.89d1d8345ccb064p-8 : inexact-ok
+= acosh upward intel96 0x1.004294p+0 : 0xb.89d1d8345ccb065p-8 : inexact-ok
+= acosh downward m68k96 0x1.004294p+0 : 0xb.89d1d8345ccb064p-8 : inexact-ok
+= acosh tonearest m68k96 0x1.004294p+0 : 0xb.89d1d8345ccb065p-8 : inexact-ok
+= acosh towardzero m68k96 0x1.004294p+0 : 0xb.89d1d8345ccb064p-8 : inexact-ok
+= acosh upward m68k96 0x1.004294p+0 : 0xb.89d1d8345ccb065p-8 : inexact-ok
+= acosh downward binary128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfaef8p-8 : inexact-ok
+= acosh tonearest binary128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfaef8p-8 : inexact-ok
+= acosh towardzero binary128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfaef8p-8 : inexact-ok
+= acosh upward binary128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfafp-8 : inexact-ok
+= acosh downward ibm128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfacp-8 : inexact-ok
+= acosh tonearest ibm128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfbp-8 : inexact-ok
+= acosh towardzero ibm128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfacp-8 : inexact-ok
+= acosh upward ibm128 0x1.004294p+0 : 0xb.89d1d8345ccb064c07e40bcfbp-8 : inexact-ok
+= acosh downward binary32 0x1.004292p+0 : 0xb.89a57p-8 : inexact-ok
+= acosh tonearest binary32 0x1.004292p+0 : 0xb.89a58p-8 : inexact-ok
+= acosh towardzero binary32 0x1.004292p+0 : 0xb.89a57p-8 : inexact-ok
+= acosh upward binary32 0x1.004292p+0 : 0xb.89a58p-8 : inexact-ok
+= acosh downward binary64 0x1.004292p+0 : 0xb.89a57c0a97e58p-8 : inexact-ok
+= acosh tonearest binary64 0x1.004292p+0 : 0xb.89a57c0a97e6p-8 : inexact-ok
+= acosh towardzero binary64 0x1.004292p+0 : 0xb.89a57c0a97e58p-8 : inexact-ok
+= acosh upward binary64 0x1.004292p+0 : 0xb.89a57c0a97e6p-8 : inexact-ok
+= acosh downward intel96 0x1.004292p+0 : 0xb.89a57c0a97e5d1bp-8 : inexact-ok
+= acosh tonearest intel96 0x1.004292p+0 : 0xb.89a57c0a97e5d1cp-8 : inexact-ok
+= acosh towardzero intel96 0x1.004292p+0 : 0xb.89a57c0a97e5d1bp-8 : inexact-ok
+= acosh upward intel96 0x1.004292p+0 : 0xb.89a57c0a97e5d1cp-8 : inexact-ok
+= acosh downward m68k96 0x1.004292p+0 : 0xb.89a57c0a97e5d1bp-8 : inexact-ok
+= acosh tonearest m68k96 0x1.004292p+0 : 0xb.89a57c0a97e5d1cp-8 : inexact-ok
+= acosh towardzero m68k96 0x1.004292p+0 : 0xb.89a57c0a97e5d1bp-8 : inexact-ok
+= acosh upward m68k96 0x1.004292p+0 : 0xb.89a57c0a97e5d1cp-8 : inexact-ok
+= acosh downward binary128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571ee8p-8 : inexact-ok
+= acosh tonearest binary128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571efp-8 : inexact-ok
+= acosh towardzero binary128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571ee8p-8 : inexact-ok
+= acosh upward binary128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571efp-8 : inexact-ok
+= acosh downward ibm128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571cp-8 : inexact-ok
+= acosh tonearest ibm128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02572p-8 : inexact-ok
+= acosh towardzero ibm128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02571cp-8 : inexact-ok
+= acosh upward ibm128 0x1.004292p+0 : 0xb.89a57c0a97e5d1b89afd02572p-8 : inexact-ok
+= acosh downward binary64 0x1.004292b93a05ep+0 : 0xb.89b588725684p-8 : inexact-ok
+= acosh tonearest binary64 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh towardzero binary64 0x1.004292b93a05ep+0 : 0xb.89b588725684p-8 : inexact-ok
+= acosh upward binary64 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh downward intel96 0x1.004292b93a05ep+0 : 0xb.89b5887256847ffp-8 : inexact-ok
+= acosh tonearest intel96 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh towardzero intel96 0x1.004292b93a05ep+0 : 0xb.89b5887256847ffp-8 : inexact-ok
+= acosh upward intel96 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh downward m68k96 0x1.004292b93a05ep+0 : 0xb.89b5887256847ffp-8 : inexact-ok
+= acosh tonearest m68k96 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh towardzero m68k96 0x1.004292b93a05ep+0 : 0xb.89b5887256847ffp-8 : inexact-ok
+= acosh upward m68k96 0x1.004292b93a05ep+0 : 0xb.89b5887256848p-8 : inexact-ok
+= acosh downward binary128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586058p-8 : inexact-ok
+= acosh tonearest binary128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586058p-8 : inexact-ok
+= acosh towardzero binary128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586058p-8 : inexact-ok
+= acosh upward binary128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea358606p-8 : inexact-ok
+= acosh downward ibm128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586p-8 : inexact-ok
+= acosh tonearest ibm128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586p-8 : inexact-ok
+= acosh towardzero ibm128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea3586p-8 : inexact-ok
+= acosh upward ibm128 0x1.004292b93a05ep+0 : 0xb.89b5887256847fffd4cea35864p-8 : inexact-ok
+acosh 0x1.0042d6fc11ef6p+0
+= acosh downward binary32 0x1.0042d8p+0 : 0xb.8fb48p-8 : inexact-ok
+= acosh tonearest binary32 0x1.0042d8p+0 : 0xb.8fb49p-8 : inexact-ok
+= acosh towardzero binary32 0x1.0042d8p+0 : 0xb.8fb48p-8 : inexact-ok
+= acosh upward binary32 0x1.0042d8p+0 : 0xb.8fb49p-8 : inexact-ok
+= acosh downward binary64 0x1.0042d8p+0 : 0xb.8fb489e37e14p-8 : inexact-ok
+= acosh tonearest binary64 0x1.0042d8p+0 : 0xb.8fb489e37e14p-8 : inexact-ok
+= acosh towardzero binary64 0x1.0042d8p+0 : 0xb.8fb489e37e14p-8 : inexact-ok
+= acosh upward binary64 0x1.0042d8p+0 : 0xb.8fb489e37e148p-8 : inexact-ok
+= acosh downward intel96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh tonearest intel96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh towardzero intel96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh upward intel96 0x1.0042d8p+0 : 0xb.8fb489e37e14391p-8 : inexact-ok
+= acosh downward m68k96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh tonearest m68k96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh towardzero m68k96 0x1.0042d8p+0 : 0xb.8fb489e37e1439p-8 : inexact-ok
+= acosh upward m68k96 0x1.0042d8p+0 : 0xb.8fb489e37e14391p-8 : inexact-ok
+= acosh downward binary128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a51828p-8 : inexact-ok
+= acosh tonearest binary128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a5183p-8 : inexact-ok
+= acosh towardzero binary128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a51828p-8 : inexact-ok
+= acosh upward binary128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a5183p-8 : inexact-ok
+= acosh downward ibm128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a518p-8 : inexact-ok
+= acosh tonearest ibm128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a518p-8 : inexact-ok
+= acosh towardzero ibm128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a518p-8 : inexact-ok
+= acosh upward ibm128 0x1.0042d8p+0 : 0xb.8fb489e37e143904f6dce9a51cp-8 : inexact-ok
+= acosh downward binary32 0x1.0042d6p+0 : 0xb.8f884p-8 : inexact-ok
+= acosh tonearest binary32 0x1.0042d6p+0 : 0xb.8f884p-8 : inexact-ok
+= acosh towardzero binary32 0x1.0042d6p+0 : 0xb.8f884p-8 : inexact-ok
+= acosh upward binary32 0x1.0042d6p+0 : 0xb.8f885p-8 : inexact-ok
+= acosh downward binary64 0x1.0042d6p+0 : 0xb.8f8844530cc6p-8 : inexact-ok
+= acosh tonearest binary64 0x1.0042d6p+0 : 0xb.8f8844530cc6p-8 : inexact-ok
+= acosh towardzero binary64 0x1.0042d6p+0 : 0xb.8f8844530cc6p-8 : inexact-ok
+= acosh upward binary64 0x1.0042d6p+0 : 0xb.8f8844530cc68p-8 : inexact-ok
+= acosh downward intel96 0x1.0042d6p+0 : 0xb.8f8844530cc6345p-8 : inexact-ok
+= acosh tonearest intel96 0x1.0042d6p+0 : 0xb.8f8844530cc6346p-8 : inexact-ok
+= acosh towardzero intel96 0x1.0042d6p+0 : 0xb.8f8844530cc6345p-8 : inexact-ok
+= acosh upward intel96 0x1.0042d6p+0 : 0xb.8f8844530cc6346p-8 : inexact-ok
+= acosh downward m68k96 0x1.0042d6p+0 : 0xb.8f8844530cc6345p-8 : inexact-ok
+= acosh tonearest m68k96 0x1.0042d6p+0 : 0xb.8f8844530cc6346p-8 : inexact-ok
+= acosh towardzero m68k96 0x1.0042d6p+0 : 0xb.8f8844530cc6345p-8 : inexact-ok
+= acosh upward m68k96 0x1.0042d6p+0 : 0xb.8f8844530cc6346p-8 : inexact-ok
+= acosh downward binary128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407d2p-8 : inexact-ok
+= acosh tonearest binary128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407d28p-8 : inexact-ok
+= acosh towardzero binary128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407d2p-8 : inexact-ok
+= acosh upward binary128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407d28p-8 : inexact-ok
+= acosh downward ibm128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407cp-8 : inexact-ok
+= acosh tonearest ibm128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407cp-8 : inexact-ok
+= acosh towardzero ibm128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805407cp-8 : inexact-ok
+= acosh upward ibm128 0x1.0042d6p+0 : 0xb.8f8844530cc6345bf51805408p-8 : inexact-ok
+= acosh downward binary64 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1dp-8 : inexact-ok
+= acosh tonearest binary64 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh towardzero binary64 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1dp-8 : inexact-ok
+= acosh upward binary64 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh downward intel96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffp-8 : inexact-ok
+= acosh tonearest intel96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh towardzero intel96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffp-8 : inexact-ok
+= acosh upward intel96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh downward m68k96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffp-8 : inexact-ok
+= acosh tonearest m68k96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh towardzero m68k96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffp-8 : inexact-ok
+= acosh upward m68k96 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d8p-8 : inexact-ok
+= acosh downward binary128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf45098p-8 : inexact-ok
+= acosh tonearest binary128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf450ap-8 : inexact-ok
+= acosh towardzero binary128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf45098p-8 : inexact-ok
+= acosh upward binary128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf450ap-8 : inexact-ok
+= acosh downward ibm128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf45p-8 : inexact-ok
+= acosh tonearest ibm128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf45p-8 : inexact-ok
+= acosh towardzero ibm128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf45p-8 : inexact-ok
+= acosh upward ibm128 0x1.0042d6fc11ef6p+0 : 0xb.8f9e10325a1d7ffff8b8abf454p-8 : inexact-ok
+acosh 0x1.00a7deb3381abp+0
+= acosh downward binary32 0x1.00a7ep+0 : 0x1.251cf8p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a7ep+0 : 0x1.251cf8p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a7ep+0 : 0x1.251cf8p-4 : inexact-ok
+= acosh upward binary32 0x1.00a7ep+0 : 0x1.251cfap-4 : inexact-ok
+= acosh downward binary64 0x1.00a7ep+0 : 0x1.251cf8a1135cap-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a7ep+0 : 0x1.251cf8a1135cap-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a7ep+0 : 0x1.251cf8a1135cap-4 : inexact-ok
+= acosh upward binary64 0x1.00a7ep+0 : 0x1.251cf8a1135cbp-4 : inexact-ok
+= acosh downward intel96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh upward intel96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4aep-4 : inexact-ok
+= acosh downward m68k96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4acp-4 : inexact-ok
+= acosh upward m68k96 0x1.00a7ep+0 : 0x1.251cf8a1135ca4aep-4 : inexact-ok
+= acosh downward binary128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698df6p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698df6p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698df6p-4 : inexact-ok
+= acosh upward binary128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698df7p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698d8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698ep-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698d8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a7ep+0 : 0x1.251cf8a1135ca4ac066bcd698ep-4 : inexact-ok
+= acosh downward binary32 0x1.00a7dep+0 : 0x1.251b38p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a7dep+0 : 0x1.251b3ap-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a7dep+0 : 0x1.251b38p-4 : inexact-ok
+= acosh upward binary32 0x1.00a7dep+0 : 0x1.251b3ap-4 : inexact-ok
+= acosh downward binary64 0x1.00a7dep+0 : 0x1.251b39d55be05p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a7dep+0 : 0x1.251b39d55be05p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a7dep+0 : 0x1.251b39d55be05p-4 : inexact-ok
+= acosh upward binary64 0x1.00a7dep+0 : 0x1.251b39d55be06p-4 : inexact-ok
+= acosh downward intel96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh upward intel96 0x1.00a7dep+0 : 0x1.251b39d55be05038p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a7dep+0 : 0x1.251b39d55be05036p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a7dep+0 : 0x1.251b39d55be05038p-4 : inexact-ok
+= acosh downward binary128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb4cep-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb4cep-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb4cep-4 : inexact-ok
+= acosh upward binary128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb4cfp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb48p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb5p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb48p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a7dep+0 : 0x1.251b39d55be0503683142b3bb5p-4 : inexact-ok
+= acosh downward binary64 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bp-4 : inexact-ok
+= acosh upward binary64 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh downward intel96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3cp-4 : inexact-ok
+= acosh downward binary128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff4641p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff4641p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff4641p-4 : inexact-ok
+= acosh upward binary128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff4642p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff46p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff468p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff46p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a7deb3381abp+0 : 0x1.251bd63ad7b3bffff52f66ff468p-4 : inexact-ok
+acosh 0x1.00a7ff291046ap+0
+= acosh downward binary32 0x1.00a8p+0 : 0x1.2538e2p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a8p+0 : 0x1.2538e4p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a8p+0 : 0x1.2538e2p-4 : inexact-ok
+= acosh upward binary32 0x1.00a8p+0 : 0x1.2538e4p-4 : inexact-ok
+= acosh downward binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd7p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd8p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd7p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd8p-4 : inexact-ok
+= acosh downward intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh upward intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh downward binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097484p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097485p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097484p-4 : inexact-ok
+= acosh upward binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097485p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff9850975p-4 : inexact-ok
+= acosh downward binary32 0x1.00a7fep+0 : 0x1.253724p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a7fep+0 : 0x1.253726p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a7fep+0 : 0x1.253724p-4 : inexact-ok
+= acosh upward binary32 0x1.00a7fep+0 : 0x1.253726p-4 : inexact-ok
+= acosh downward binary64 0x1.00a7fep+0 : 0x1.253725512607dp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a7fep+0 : 0x1.253725512607dp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a7fep+0 : 0x1.253725512607dp-4 : inexact-ok
+= acosh upward binary64 0x1.00a7fep+0 : 0x1.253725512607ep-4 : inexact-ok
+= acosh downward intel96 0x1.00a7fep+0 : 0x1.253725512607d666p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a7fep+0 : 0x1.253725512607d668p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a7fep+0 : 0x1.253725512607d666p-4 : inexact-ok
+= acosh upward intel96 0x1.00a7fep+0 : 0x1.253725512607d668p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a7fep+0 : 0x1.253725512607d666p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a7fep+0 : 0x1.253725512607d668p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a7fep+0 : 0x1.253725512607d666p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a7fep+0 : 0x1.253725512607d668p-4 : inexact-ok
+= acosh downward binary128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb375p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb376p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb375p-4 : inexact-ok
+= acosh upward binary128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb376p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb3p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb38p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb3p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a7fep+0 : 0x1.253725512607d66772cccf1eb38p-4 : inexact-ok
+= acosh downward binary64 0x1.00a7ff291046ap+0 : 0x1.253828741f38fp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a7ff291046ap+0 : 0x1.253828741f38fp-4 : inexact-ok
+= acosh upward binary64 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh downward intel96 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a7ff291046ap+0 : 0x1.253828741f39p-4 : inexact-ok
+= acosh downward binary128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b544a2p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b544a2p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b544a2p-4 : inexact-ok
+= acosh upward binary128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b544a3p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b5448p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b5448p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b5448p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a7ff291046ap+0 : 0x1.253828741f38fffff64335b545p-4 : inexact-ok
+acosh 0x1.00a800422847ap+0
+= acosh downward binary32 0x1.00a802p+0 : 0x1.253aa2p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a802p+0 : 0x1.253aa2p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a802p+0 : 0x1.253aa2p-4 : inexact-ok
+= acosh upward binary32 0x1.00a802p+0 : 0x1.253aa4p-4 : inexact-ok
+= acosh downward binary64 0x1.00a802p+0 : 0x1.253aa290b0822p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a802p+0 : 0x1.253aa290b0823p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a802p+0 : 0x1.253aa290b0822p-4 : inexact-ok
+= acosh upward binary64 0x1.00a802p+0 : 0x1.253aa290b0823p-4 : inexact-ok
+= acosh downward intel96 0x1.00a802p+0 : 0x1.253aa290b0822ce2p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a802p+0 : 0x1.253aa290b0822ce4p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a802p+0 : 0x1.253aa290b0822ce2p-4 : inexact-ok
+= acosh upward intel96 0x1.00a802p+0 : 0x1.253aa290b0822ce4p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a802p+0 : 0x1.253aa290b0822ce2p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a802p+0 : 0x1.253aa290b0822ce4p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a802p+0 : 0x1.253aa290b0822ce2p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a802p+0 : 0x1.253aa290b0822ce4p-4 : inexact-ok
+= acosh downward binary128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d4092p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d4093p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d4092p-4 : inexact-ok
+= acosh upward binary128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d4093p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d408p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d408p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d408p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a802p+0 : 0x1.253aa290b0822ce377361e6d41p-4 : inexact-ok
+= acosh downward binary32 0x1.00a8p+0 : 0x1.2538e2p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a8p+0 : 0x1.2538e4p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a8p+0 : 0x1.2538e2p-4 : inexact-ok
+= acosh upward binary32 0x1.00a8p+0 : 0x1.2538e4p-4 : inexact-ok
+= acosh downward binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd7p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd8p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd7p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8p+0 : 0x1.2538e3f23ffd8p-4 : inexact-ok
+= acosh downward intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh upward intel96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8p+0 : 0x1.2538e3f23ffd7cdp-4 : inexact-ok
+= acosh downward binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097484p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097485p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097484p-4 : inexact-ok
+= acosh upward binary128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff985097485p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff98509748p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8p+0 : 0x1.2538e3f23ffd7ccf0ff9850975p-4 : inexact-ok
+= acosh downward binary64 0x1.00a800422847ap+0 : 0x1.25391da7f5afep-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a800422847ap+0 : 0x1.25391da7f5afep-4 : inexact-ok
+= acosh upward binary64 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh downward intel96 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a800422847ap+0 : 0x1.25391da7f5affp-4 : inexact-ok
+= acosh downward binary128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04ec3p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04ec3p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04ec3p-4 : inexact-ok
+= acosh upward binary128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04ec4p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04e8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04fp-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04e8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a800422847ap+0 : 0x1.25391da7f5afeffff5588ec04fp-4 : inexact-ok
+acosh 0x1.00a8178044ea8p+0
+= acosh downward binary32 0x1.00a818p+0 : 0x1.254dd2p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a818p+0 : 0x1.254dd2p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a818p+0 : 0x1.254dd2p-4 : inexact-ok
+= acosh upward binary32 0x1.00a818p+0 : 0x1.254dd4p-4 : inexact-ok
+= acosh downward binary64 0x1.00a818p+0 : 0x1.254dd2afe4abcp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a818p+0 : 0x1.254dd2afe4abcp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a818p+0 : 0x1.254dd2afe4abcp-4 : inexact-ok
+= acosh upward binary64 0x1.00a818p+0 : 0x1.254dd2afe4abdp-4 : inexact-ok
+= acosh downward intel96 0x1.00a818p+0 : 0x1.254dd2afe4abc368p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a818p+0 : 0x1.254dd2afe4abc36ap-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a818p+0 : 0x1.254dd2afe4abc368p-4 : inexact-ok
+= acosh upward intel96 0x1.00a818p+0 : 0x1.254dd2afe4abc36ap-4 : inexact-ok
+= acosh downward m68k96 0x1.00a818p+0 : 0x1.254dd2afe4abc368p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a818p+0 : 0x1.254dd2afe4abc36ap-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a818p+0 : 0x1.254dd2afe4abc368p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a818p+0 : 0x1.254dd2afe4abc36ap-4 : inexact-ok
+= acosh downward binary128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec4aep-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec4aep-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec4aep-4 : inexact-ok
+= acosh upward binary128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec4afp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec48p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec48p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec48p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a818p+0 : 0x1.254dd2afe4abc369a347f79ec5p-4 : inexact-ok
+= acosh downward binary32 0x1.00a816p+0 : 0x1.254c14p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a816p+0 : 0x1.254c14p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a816p+0 : 0x1.254c14p-4 : inexact-ok
+= acosh upward binary32 0x1.00a816p+0 : 0x1.254c16p-4 : inexact-ok
+= acosh downward binary64 0x1.00a816p+0 : 0x1.254c142eb8df3p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a816p+0 : 0x1.254c142eb8df4p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a816p+0 : 0x1.254c142eb8df3p-4 : inexact-ok
+= acosh upward binary64 0x1.00a816p+0 : 0x1.254c142eb8df4p-4 : inexact-ok
+= acosh downward intel96 0x1.00a816p+0 : 0x1.254c142eb8df3b28p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a816p+0 : 0x1.254c142eb8df3b2ap-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a816p+0 : 0x1.254c142eb8df3b28p-4 : inexact-ok
+= acosh upward intel96 0x1.00a816p+0 : 0x1.254c142eb8df3b2ap-4 : inexact-ok
+= acosh downward m68k96 0x1.00a816p+0 : 0x1.254c142eb8df3b28p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a816p+0 : 0x1.254c142eb8df3b2ap-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a816p+0 : 0x1.254c142eb8df3b28p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a816p+0 : 0x1.254c142eb8df3b2ap-4 : inexact-ok
+= acosh downward binary128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c964p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c965p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c964p-4 : inexact-ok
+= acosh upward binary128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c965p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c9p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c98p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c9p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a816p+0 : 0x1.254c142eb8df3b29e68dd8a9c98p-4 : inexact-ok
+= acosh downward binary64 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh downward intel96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f9p-4 : inexact-ok
+= acosh downward binary128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c63336p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c63337p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c63336p-4 : inexact-ok
+= acosh upward binary128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c63337p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c633p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c633p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c633p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8178044ea8p+0 : 0x1.254d634bf31f8ffffd7678c6338p-4 : inexact-ok
+acosh 0x1.00a83624f0d22p+0
+= acosh downward binary32 0x1.00a838p+0 : 0x1.2569b8p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a838p+0 : 0x1.2569bap-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a838p+0 : 0x1.2569b8p-4 : inexact-ok
+= acosh upward binary32 0x1.00a838p+0 : 0x1.2569bap-4 : inexact-ok
+= acosh downward binary64 0x1.00a838p+0 : 0x1.2569b9590b2e1p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a838p+0 : 0x1.2569b9590b2e1p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a838p+0 : 0x1.2569b9590b2e1p-4 : inexact-ok
+= acosh upward binary64 0x1.00a838p+0 : 0x1.2569b9590b2e2p-4 : inexact-ok
+= acosh downward intel96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh upward intel96 0x1.00a838p+0 : 0x1.2569b9590b2e1098p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a838p+0 : 0x1.2569b9590b2e1096p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a838p+0 : 0x1.2569b9590b2e1098p-4 : inexact-ok
+= acosh downward binary128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504660d8p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504660d8p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504660d8p-4 : inexact-ok
+= acosh upward binary128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504660d9p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d325046608p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504661p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d325046608p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a838p+0 : 0x1.2569b9590b2e10963d32504661p-4 : inexact-ok
+= acosh downward binary32 0x1.00a836p+0 : 0x1.2567fap-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a836p+0 : 0x1.2567fcp-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a836p+0 : 0x1.2567fap-4 : inexact-ok
+= acosh upward binary32 0x1.00a836p+0 : 0x1.2567fcp-4 : inexact-ok
+= acosh downward binary64 0x1.00a836p+0 : 0x1.2567fb0267a27p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a836p+0 : 0x1.2567fb0267a28p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a836p+0 : 0x1.2567fb0267a27p-4 : inexact-ok
+= acosh upward binary64 0x1.00a836p+0 : 0x1.2567fb0267a28p-4 : inexact-ok
+= acosh downward intel96 0x1.00a836p+0 : 0x1.2567fb0267a27982p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a836p+0 : 0x1.2567fb0267a27984p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a836p+0 : 0x1.2567fb0267a27982p-4 : inexact-ok
+= acosh upward intel96 0x1.00a836p+0 : 0x1.2567fb0267a27984p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a836p+0 : 0x1.2567fb0267a27982p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a836p+0 : 0x1.2567fb0267a27984p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a836p+0 : 0x1.2567fb0267a27982p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a836p+0 : 0x1.2567fb0267a27984p-4 : inexact-ok
+= acosh downward binary128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4aep-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4aep-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4aep-4 : inexact-ok
+= acosh upward binary128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4ae1p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4a8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4bp-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4a8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a836p+0 : 0x1.2567fb0267a279837a43548c4bp-4 : inexact-ok
+= acosh downward binary64 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06p-4 : inexact-ok
+= acosh upward binary64 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh downward intel96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a83624f0d22p+0 : 0x1.25681b3685b07p-4 : inexact-ok
+= acosh downward binary128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a98f9p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a98f9p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a98f9p-4 : inexact-ok
+= acosh upward binary128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a98fap-4 : inexact-ok
+= acosh downward ibm128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a988p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a99p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a988p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a83624f0d22p+0 : 0x1.25681b3685b06ffff10bb87a99p-4 : inexact-ok
+acosh 0x1.00a851f655836p+0
+= acosh downward binary32 0x1.00a852p+0 : 0x1.258062p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a852p+0 : 0x1.258062p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a852p+0 : 0x1.258062p-4 : inexact-ok
+= acosh upward binary32 0x1.00a852p+0 : 0x1.258064p-4 : inexact-ok
+= acosh downward binary64 0x1.00a852p+0 : 0x1.258062cda836ap-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a852p+0 : 0x1.258062cda836bp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a852p+0 : 0x1.258062cda836ap-4 : inexact-ok
+= acosh upward binary64 0x1.00a852p+0 : 0x1.258062cda836bp-4 : inexact-ok
+= acosh downward intel96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh upward intel96 0x1.00a852p+0 : 0x1.258062cda836ac4cp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a852p+0 : 0x1.258062cda836ac4ap-4 : inexact-ok
+= acosh upward m68k96 0x1.00a852p+0 : 0x1.258062cda836ac4cp-4 : inexact-ok
+= acosh downward binary128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d90ecp-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d90ecp-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d90ecp-4 : inexact-ok
+= acosh upward binary128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d90edp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d908p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d91p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d908p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a852p+0 : 0x1.258062cda836ac4af0ffef2d91p-4 : inexact-ok
+= acosh downward binary32 0x1.00a85p+0 : 0x1.257ea4p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a85p+0 : 0x1.257ea4p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a85p+0 : 0x1.257ea4p-4 : inexact-ok
+= acosh upward binary32 0x1.00a85p+0 : 0x1.257ea6p-4 : inexact-ok
+= acosh downward binary64 0x1.00a85p+0 : 0x1.257ea4998a721p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a85p+0 : 0x1.257ea4998a721p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a85p+0 : 0x1.257ea4998a721p-4 : inexact-ok
+= acosh upward binary64 0x1.00a85p+0 : 0x1.257ea4998a722p-4 : inexact-ok
+= acosh downward intel96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh upward intel96 0x1.00a85p+0 : 0x1.257ea4998a7216dep-4 : inexact-ok
+= acosh downward m68k96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a85p+0 : 0x1.257ea4998a7216dcp-4 : inexact-ok
+= acosh upward m68k96 0x1.00a85p+0 : 0x1.257ea4998a7216dep-4 : inexact-ok
+= acosh downward binary128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701ecccp-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701eccdp-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701ecccp-4 : inexact-ok
+= acosh upward binary128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701eccdp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701ec8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701edp-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701ec8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a85p+0 : 0x1.257ea4998a7216dc12b55701edp-4 : inexact-ok
+= acosh downward binary64 0x1.00a851f655836p+0 : 0x1.25805a613011cp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a851f655836p+0 : 0x1.25805a613011cp-4 : inexact-ok
+= acosh upward binary64 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh downward intel96 0x1.00a851f655836p+0 : 0x1.25805a613011cffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a851f655836p+0 : 0x1.25805a613011cffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a851f655836p+0 : 0x1.25805a613011cffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a851f655836p+0 : 0x1.25805a613011cffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a851f655836p+0 : 0x1.25805a613011dp-4 : inexact-ok
+= acosh downward binary128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641d22p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641d22p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641d22p-4 : inexact-ok
+= acosh upward binary128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641d23p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641dp-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641dp-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641dp-4 : inexact-ok
+= acosh upward ibm128 0x1.00a851f655836p+0 : 0x1.25805a613011cffffb720f641d8p-4 : inexact-ok
+acosh 0x1.00a86ce6bcfb9p+0
+= acosh downward binary32 0x1.00a86ep+0 : 0x1.2598c8p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a86ep+0 : 0x1.2598c8p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a86ep+0 : 0x1.2598c8p-4 : inexact-ok
+= acosh upward binary32 0x1.00a86ep+0 : 0x1.2598cap-4 : inexact-ok
+= acosh downward binary64 0x1.00a86ep+0 : 0x1.2598c890ab32bp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a86ep+0 : 0x1.2598c890ab32bp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a86ep+0 : 0x1.2598c890ab32bp-4 : inexact-ok
+= acosh upward binary64 0x1.00a86ep+0 : 0x1.2598c890ab32cp-4 : inexact-ok
+= acosh downward intel96 0x1.00a86ep+0 : 0x1.2598c890ab32b25p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a86ep+0 : 0x1.2598c890ab32b252p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a86ep+0 : 0x1.2598c890ab32b25p-4 : inexact-ok
+= acosh upward intel96 0x1.00a86ep+0 : 0x1.2598c890ab32b252p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a86ep+0 : 0x1.2598c890ab32b25p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a86ep+0 : 0x1.2598c890ab32b252p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a86ep+0 : 0x1.2598c890ab32b25p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a86ep+0 : 0x1.2598c890ab32b252p-4 : inexact-ok
+= acosh downward binary128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d702p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d703p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d702p-4 : inexact-ok
+= acosh upward binary128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d703p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d7p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d7p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d7p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a86ep+0 : 0x1.2598c890ab32b25108ca3547d78p-4 : inexact-ok
+= acosh downward binary32 0x1.00a86cp+0 : 0x1.25970ap-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a86cp+0 : 0x1.25970ap-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a86cp+0 : 0x1.25970ap-4 : inexact-ok
+= acosh upward binary32 0x1.00a86cp+0 : 0x1.25970cp-4 : inexact-ok
+= acosh downward binary64 0x1.00a86cp+0 : 0x1.25970a81b2195p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a86cp+0 : 0x1.25970a81b2195p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a86cp+0 : 0x1.25970a81b2195p-4 : inexact-ok
+= acosh upward binary64 0x1.00a86cp+0 : 0x1.25970a81b2196p-4 : inexact-ok
+= acosh downward intel96 0x1.00a86cp+0 : 0x1.25970a81b219568ap-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a86cp+0 : 0x1.25970a81b219568cp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a86cp+0 : 0x1.25970a81b219568ap-4 : inexact-ok
+= acosh upward intel96 0x1.00a86cp+0 : 0x1.25970a81b219568cp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a86cp+0 : 0x1.25970a81b219568ap-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a86cp+0 : 0x1.25970a81b219568cp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a86cp+0 : 0x1.25970a81b219568ap-4 : inexact-ok
+= acosh upward m68k96 0x1.00a86cp+0 : 0x1.25970a81b219568cp-4 : inexact-ok
+= acosh downward binary128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9b22p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9b23p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9b22p-4 : inexact-ok
+= acosh upward binary128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9b23p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9bp-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9bp-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9bp-4 : inexact-ok
+= acosh upward ibm128 0x1.00a86cp+0 : 0x1.25970a81b219568b204e54ff9b8p-4 : inexact-ok
+= acosh downward binary64 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fp-4 : inexact-ok
+= acosh upward binary64 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh downward intel96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b1p-4 : inexact-ok
+= acosh downward binary128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9cb6p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9cb6p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9cb6p-4 : inexact-ok
+= acosh upward binary128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9cb7p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9c8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9c8p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9c8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a86ce6bcfb9p+0 : 0x1.2597d38764b0fffff6d235cd9dp-4 : inexact-ok
+acosh 0x1.00a888136de79p+0
+= acosh downward binary32 0x1.00a88ap+0 : 0x1.25b12cp-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a88ap+0 : 0x1.25b12cp-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a88ap+0 : 0x1.25b12cp-4 : inexact-ok
+= acosh upward binary32 0x1.00a88ap+0 : 0x1.25b12ep-4 : inexact-ok
+= acosh downward binary64 0x1.00a88ap+0 : 0x1.25b12c4bf23d7p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a88ap+0 : 0x1.25b12c4bf23d8p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a88ap+0 : 0x1.25b12c4bf23d7p-4 : inexact-ok
+= acosh upward binary64 0x1.00a88ap+0 : 0x1.25b12c4bf23d8p-4 : inexact-ok
+= acosh downward intel96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7efp-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef2p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7efp-4 : inexact-ok
+= acosh upward intel96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef2p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7efp-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef2p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7efp-4 : inexact-ok
+= acosh upward m68k96 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef2p-4 : inexact-ok
+= acosh downward binary128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48ep-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48fp-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48ep-4 : inexact-ok
+= acosh upward binary128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48fp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff48p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a88ap+0 : 0x1.25b12c4bf23d7ef17059706ff5p-4 : inexact-ok
+= acosh downward binary32 0x1.00a888p+0 : 0x1.25af6ep-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a888p+0 : 0x1.25af6ep-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a888p+0 : 0x1.25af6ep-4 : inexact-ok
+= acosh upward binary32 0x1.00a888p+0 : 0x1.25af7p-4 : inexact-ok
+= acosh downward binary64 0x1.00a888p+0 : 0x1.25af6e62148e5p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a888p+0 : 0x1.25af6e62148e6p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a888p+0 : 0x1.25af6e62148e5p-4 : inexact-ok
+= acosh upward binary64 0x1.00a888p+0 : 0x1.25af6e62148e6p-4 : inexact-ok
+= acosh downward intel96 0x1.00a888p+0 : 0x1.25af6e62148e5e02p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a888p+0 : 0x1.25af6e62148e5e04p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a888p+0 : 0x1.25af6e62148e5e02p-4 : inexact-ok
+= acosh upward intel96 0x1.00a888p+0 : 0x1.25af6e62148e5e04p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a888p+0 : 0x1.25af6e62148e5e02p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a888p+0 : 0x1.25af6e62148e5e04p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a888p+0 : 0x1.25af6e62148e5e02p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a888p+0 : 0x1.25af6e62148e5e04p-4 : inexact-ok
+= acosh downward binary128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce9167p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce9168p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce9167p-4 : inexact-ok
+= acosh upward binary128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce9168p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce91p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce918p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce91p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a888p+0 : 0x1.25af6e62148e5e03aa03d6ce918p-4 : inexact-ok
+= acosh downward binary64 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbp-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbp-4 : inexact-ok
+= acosh upward binary64 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh downward intel96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a888136de79p+0 : 0x1.25af7f4e069fcp-4 : inexact-ok
+= acosh downward binary128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29fe1p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29fe2p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29fe1p-4 : inexact-ok
+= acosh upward binary128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29fe2p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29f8p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b2ap-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b29f8p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a888136de79p+0 : 0x1.25af7f4e069fbffffd3099b2ap-4 : inexact-ok
+acosh 0x1.00a8abbf7ef1ap+0
+= acosh downward binary32 0x1.00a8acp+0 : 0x1.25cec6p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a8acp+0 : 0x1.25cec8p-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a8acp+0 : 0x1.25cec6p-4 : inexact-ok
+= acosh upward binary32 0x1.00a8acp+0 : 0x1.25cec8p-4 : inexact-ok
+= acosh downward binary64 0x1.00a8acp+0 : 0x1.25cec73e8065p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8acp+0 : 0x1.25cec73e80651p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8acp+0 : 0x1.25cec73e8065p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8acp+0 : 0x1.25cec73e80651p-4 : inexact-ok
+= acosh downward intel96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh upward intel96 0x1.00a8acp+0 : 0x1.25cec73e80650cdap-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8acp+0 : 0x1.25cec73e80650cd8p-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8acp+0 : 0x1.25cec73e80650cdap-4 : inexact-ok
+= acosh downward binary128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d29efp-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d29fp-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d29efp-4 : inexact-ok
+= acosh upward binary128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d29fp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d298p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d2ap-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d298p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8acp+0 : 0x1.25cec73e80650cd86d8df15d2ap-4 : inexact-ok
+= acosh downward binary32 0x1.00a8aap+0 : 0x1.25cd08p-4 : inexact-ok
+= acosh tonearest binary32 0x1.00a8aap+0 : 0x1.25cd0ap-4 : inexact-ok
+= acosh towardzero binary32 0x1.00a8aap+0 : 0x1.25cd08p-4 : inexact-ok
+= acosh upward binary32 0x1.00a8aap+0 : 0x1.25cd0ap-4 : inexact-ok
+= acosh downward binary64 0x1.00a8aap+0 : 0x1.25cd0981a54b9p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8aap+0 : 0x1.25cd0981a54bap-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8aap+0 : 0x1.25cd0981a54b9p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8aap+0 : 0x1.25cd0981a54bap-4 : inexact-ok
+= acosh downward intel96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh upward intel96 0x1.00a8aap+0 : 0x1.25cd0981a54b995cp-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8aap+0 : 0x1.25cd0981a54b995ap-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8aap+0 : 0x1.25cd0981a54b995cp-4 : inexact-ok
+= acosh downward binary128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f242ap-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f242bp-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f242ap-4 : inexact-ok
+= acosh upward binary128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f242bp-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f24p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f24p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f24p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8aap+0 : 0x1.25cd0981a54b995a643f0e3f248p-4 : inexact-ok
+= acosh downward binary64 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45p-4 : inexact-ok
+= acosh tonearest binary64 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh towardzero binary64 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45p-4 : inexact-ok
+= acosh upward binary64 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh downward intel96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffep-4 : inexact-ok
+= acosh tonearest intel96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh towardzero intel96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffep-4 : inexact-ok
+= acosh upward intel96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh downward m68k96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffep-4 : inexact-ok
+= acosh tonearest m68k96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh towardzero m68k96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffep-4 : inexact-ok
+= acosh upward m68k96 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb46p-4 : inexact-ok
+= acosh downward binary128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c917p-4 : inexact-ok
+= acosh tonearest binary128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c918p-4 : inexact-ok
+= acosh towardzero binary128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c917p-4 : inexact-ok
+= acosh upward binary128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c918p-4 : inexact-ok
+= acosh downward ibm128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c9p-4 : inexact-ok
+= acosh tonearest ibm128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c9p-4 : inexact-ok
+= acosh towardzero ibm128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c9p-4 : inexact-ok
+= acosh upward ibm128 0x1.00a8abbf7ef1ap+0 : 0x1.25ce8f16afb45ffffdb93830c98p-4 : inexact-ok
+acosh 0x1.1p+1
+= acosh downward binary32 0x2.2p+0 : 0x1.62e42ep+0 : inexact-ok
+= acosh tonearest binary32 0x2.2p+0 : 0x1.62e43p+0 : inexact-ok
+= acosh towardzero binary32 0x2.2p+0 : 0x1.62e42ep+0 : inexact-ok
+= acosh upward binary32 0x2.2p+0 : 0x1.62e43p+0 : inexact-ok
+= acosh downward binary64 0x2.2p+0 : 0x1.62e42fefa39efp+0 : inexact-ok
+= acosh tonearest binary64 0x2.2p+0 : 0x1.62e42fefa39efp+0 : inexact-ok
+= acosh towardzero binary64 0x2.2p+0 : 0x1.62e42fefa39efp+0 : inexact-ok
+= acosh upward binary64 0x2.2p+0 : 0x1.62e42fefa39fp+0 : inexact-ok
+= acosh downward intel96 0x2.2p+0 : 0x1.62e42fefa39ef356p+0 : inexact-ok
+= acosh tonearest intel96 0x2.2p+0 : 0x1.62e42fefa39ef358p+0 : inexact-ok
+= acosh towardzero intel96 0x2.2p+0 : 0x1.62e42fefa39ef356p+0 : inexact-ok
+= acosh upward intel96 0x2.2p+0 : 0x1.62e42fefa39ef358p+0 : inexact-ok
+= acosh downward m68k96 0x2.2p+0 : 0x1.62e42fefa39ef356p+0 : inexact-ok
+= acosh tonearest m68k96 0x2.2p+0 : 0x1.62e42fefa39ef358p+0 : inexact-ok
+= acosh towardzero m68k96 0x2.2p+0 : 0x1.62e42fefa39ef356p+0 : inexact-ok
+= acosh upward m68k96 0x2.2p+0 : 0x1.62e42fefa39ef358p+0 : inexact-ok
+= acosh downward binary128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673007e5p+0 : inexact-ok
+= acosh tonearest binary128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673007e6p+0 : inexact-ok
+= acosh towardzero binary128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673007e5p+0 : inexact-ok
+= acosh upward binary128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673007e6p+0 : inexact-ok
+= acosh downward ibm128 0x2.2p+0 : 0x1.62e42fefa39ef35793c76730078p+0 : inexact-ok
+= acosh tonearest ibm128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673008p+0 : inexact-ok
+= acosh towardzero ibm128 0x2.2p+0 : 0x1.62e42fefa39ef35793c76730078p+0 : inexact-ok
+= acosh upward ibm128 0x2.2p+0 : 0x1.62e42fefa39ef35793c7673008p+0 : inexact-ok
+acosh 0x1.3bf8009648dcp+16
+= acosh downward binary32 0x1.3bf802p+16 : 0xb.fe74bp+0 : inexact-ok
+= acosh tonearest binary32 0x1.3bf802p+16 : 0xb.fe74bp+0 : inexact-ok
+= acosh towardzero binary32 0x1.3bf802p+16 : 0xb.fe74bp+0 : inexact-ok
+= acosh upward binary32 0x1.3bf802p+16 : 0xb.fe74cp+0 : inexact-ok
+= acosh downward binary64 0x1.3bf802p+16 : 0xb.fe74b077f39ap+0 : inexact-ok
+= acosh tonearest binary64 0x1.3bf802p+16 : 0xb.fe74b077f39ap+0 : inexact-ok
+= acosh towardzero binary64 0x1.3bf802p+16 : 0xb.fe74b077f39ap+0 : inexact-ok
+= acosh upward binary64 0x1.3bf802p+16 : 0xb.fe74b077f39a8p+0 : inexact-ok
+= acosh downward intel96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh tonearest intel96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh towardzero intel96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh upward intel96 0x1.3bf802p+16 : 0xb.fe74b077f39a22dp+0 : inexact-ok
+= acosh downward m68k96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh tonearest m68k96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh towardzero m68k96 0x1.3bf802p+16 : 0xb.fe74b077f39a22cp+0 : inexact-ok
+= acosh upward m68k96 0x1.3bf802p+16 : 0xb.fe74b077f39a22dp+0 : inexact-ok
+= acosh downward binary128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891cc05p+0 : inexact-ok
+= acosh tonearest binary128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891cc058p+0 : inexact-ok
+= acosh towardzero binary128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891cc05p+0 : inexact-ok
+= acosh upward binary128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891cc058p+0 : inexact-ok
+= acosh downward ibm128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891ccp+0 : inexact-ok
+= acosh tonearest ibm128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891ccp+0 : inexact-ok
+= acosh towardzero ibm128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891ccp+0 : inexact-ok
+= acosh upward ibm128 0x1.3bf802p+16 : 0xb.fe74b077f39a22c0afc2891cc4p+0 : inexact-ok
+= acosh downward binary32 0x1.3bf8p+16 : 0xb.fe74ap+0 : inexact-ok
+= acosh tonearest binary32 0x1.3bf8p+16 : 0xb.fe74bp+0 : inexact-ok
+= acosh towardzero binary32 0x1.3bf8p+16 : 0xb.fe74ap+0 : inexact-ok
+= acosh upward binary32 0x1.3bf8p+16 : 0xb.fe74bp+0 : inexact-ok
+= acosh downward binary64 0x1.3bf8p+16 : 0xb.fe74aed920318p+0 : inexact-ok
+= acosh tonearest binary64 0x1.3bf8p+16 : 0xb.fe74aed920318p+0 : inexact-ok
+= acosh towardzero binary64 0x1.3bf8p+16 : 0xb.fe74aed920318p+0 : inexact-ok
+= acosh upward binary64 0x1.3bf8p+16 : 0xb.fe74aed92032p+0 : inexact-ok
+= acosh downward intel96 0x1.3bf8p+16 : 0xb.fe74aed92031a37p+0 : inexact-ok
+= acosh tonearest intel96 0x1.3bf8p+16 : 0xb.fe74aed92031a38p+0 : inexact-ok
+= acosh towardzero intel96 0x1.3bf8p+16 : 0xb.fe74aed92031a37p+0 : inexact-ok
+= acosh upward intel96 0x1.3bf8p+16 : 0xb.fe74aed92031a38p+0 : inexact-ok
+= acosh downward m68k96 0x1.3bf8p+16 : 0xb.fe74aed92031a37p+0 : inexact-ok
+= acosh tonearest m68k96 0x1.3bf8p+16 : 0xb.fe74aed92031a38p+0 : inexact-ok
+= acosh towardzero m68k96 0x1.3bf8p+16 : 0xb.fe74aed92031a37p+0 : inexact-ok
+= acosh upward m68k96 0x1.3bf8p+16 : 0xb.fe74aed92031a38p+0 : inexact-ok
+= acosh downward binary128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14fp+0 : inexact-ok
+= acosh tonearest binary128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14f8p+0 : inexact-ok
+= acosh towardzero binary128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14fp+0 : inexact-ok
+= acosh upward binary128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14f8p+0 : inexact-ok
+= acosh downward ibm128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14p+0 : inexact-ok
+= acosh tonearest ibm128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14p+0 : inexact-ok
+= acosh towardzero ibm128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd14p+0 : inexact-ok
+= acosh upward ibm128 0x1.3bf8p+16 : 0xb.fe74aed92031a37c22a37edd18p+0 : inexact-ok
+= acosh downward binary64 0x1.3bf8009648dcp+16 : 0xb.fe74af52e329p+0 : inexact-ok
+= acosh tonearest binary64 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh towardzero binary64 0x1.3bf8009648dcp+16 : 0xb.fe74af52e329p+0 : inexact-ok
+= acosh upward binary64 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh downward intel96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffp+0 : inexact-ok
+= acosh tonearest intel96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh towardzero intel96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffp+0 : inexact-ok
+= acosh upward intel96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh downward m68k96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffp+0 : inexact-ok
+= acosh tonearest m68k96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh towardzero m68k96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffp+0 : inexact-ok
+= acosh upward m68k96 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh downward binary128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297fffffffffffff5p+0 : inexact-ok
+= acosh tonearest binary128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297fffffffffffff58p+0 : inexact-ok
+= acosh towardzero binary128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297fffffffffffff5p+0 : inexact-ok
+= acosh upward binary128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297fffffffffffff58p+0 : inexact-ok
+= acosh downward ibm128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffffffffffffcp+0 : inexact-ok
+= acosh tonearest ibm128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
+= acosh towardzero ibm128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3297ffffffffffffcp+0 : inexact-ok
+= acosh upward ibm128 0x1.3bf8009648dcp+16 : 0xb.fe74af52e3298p+0 : inexact-ok
 acosh max
 = acosh downward binary32 0xf.fffffp+124 : 0x5.96a7ep+4 : inexact-ok
 = acosh tonearest binary32 0xf.fffffp+124 : 0x5.96a7ep+4 : inexact-ok
@@ -12789,11 +12789,11 @@ fma 0x1p-149 0x1p-149 0x1p-126
 = fma tonearest ibm128 0x8p-152 0x8p-152 0x4p-128 : 0x4p-128 : inexact
 = fma towardzero ibm128 0x8p-152 0x8p-152 0x4p-128 : 0x4p-128 : inexact
 = fma upward ibm128 0x8p-152 0x8p-152 0x4p-128 : 0x4.00000000000000000000000002p-128 : inexact
-fma 0x1p-149 -0x1p-149 0x1p-126
-= fma downward binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact underflow:before-rounding errno-erange-ok:before-rounding
-= fma towardzero binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact underflow:before-rounding errno-erange-ok:before-rounding
+fma 0x1p-149 -0x1p-149 0x1p-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact underflow:before-rounding underflow-ok:arg-ibm128:before-rounding errno-erange-ok:before-rounding
+= fma towardzero binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact underflow:before-rounding underflow-ok:arg-ibm128:before-rounding errno-erange-ok:before-rounding
 = fma downward binary64 0x8p-152 -0x8p-152 0x4p-128 : 0x3.ffffffffffffep-128 : inexact
 = fma tonearest binary64 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact
 = fma towardzero binary64 0x8p-152 -0x8p-152 0x4p-128 : 0x3.ffffffffffffep-128 : inexact
@@ -12814,11 +12814,11 @@ fma 0x1p-149 -0x1p-149 0x1p-126
 = fma tonearest ibm128 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact
 = fma towardzero ibm128 0x8p-152 -0x8p-152 0x4p-128 : 0x3.ffffffffffffffffffffffffffp-128 : inexact
 = fma upward ibm128 0x8p-152 -0x8p-152 0x4p-128 : 0x4p-128 : inexact
-fma 0x1p-149 0x1p-149 -0x1p-126
-= fma downward binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact underflow:before-rounding errno-erange-ok:before-rounding
-= fma tonearest binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact underflow:before-rounding errno-erange-ok:before-rounding
-= fma towardzero binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
+fma 0x1p-149 0x1p-149 -0x1p-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact underflow:before-rounding underflow-ok:arg-ibm128:before-rounding errno-erange-ok:before-rounding
+= fma tonearest binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact underflow:before-rounding underflow-ok:arg-ibm128:before-rounding errno-erange-ok:before-rounding
+= fma towardzero binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 0x8p-152 -0x4p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact
 = fma tonearest binary64 0x8p-152 0x8p-152 -0x4p-128 : -0x4p-128 : inexact
 = fma towardzero binary64 0x8p-152 0x8p-152 -0x4p-128 : -0x3.ffffffffffffep-128 : inexact
@@ -12864,11 +12864,11 @@ fma 0x1p-149 -0x1p-149 -0x1p-126
 = fma tonearest ibm128 0x8p-152 -0x8p-152 -0x4p-128 : -0x4p-128 : inexact
 = fma towardzero ibm128 0x8p-152 -0x8p-152 -0x4p-128 : -0x4p-128 : inexact
 = fma upward ibm128 0x8p-152 -0x8p-152 -0x4p-128 : -0x4p-128 : inexact
-fma 0x1p-149 0x1p-149 0x0.fffffep-126
-= fma downward binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x4p-128 : inexact underflow errno-erange-ok
+fma 0x1p-149 0x1p-149 0x0.fffffep-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x4p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma tonearest binary64 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma towardzero binary64 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
@@ -12889,11 +12889,11 @@ fma 0x1p-149 0x1p-149 0x0.fffffep-126
 = fma tonearest ibm128 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma towardzero ibm128 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma upward ibm128 0x8p-152 0x8p-152 0x3.fffff8p-128 : 0x3.fffff800000000000000000001p-128 : inexact
-fma 0x1p-149 -0x1p-149 0x0.fffffep-126
-= fma downward binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffffp-128 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffffp-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow errno-erange-ok
+fma 0x1p-149 -0x1p-149 0x0.fffffep-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffffp-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffffp-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff7ffffffep-128 : inexact
 = fma tonearest binary64 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma towardzero binary64 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff7ffffffep-128 : inexact
@@ -12914,11 +12914,11 @@ fma 0x1p-149 -0x1p-149 0x0.fffffep-126
 = fma tonearest ibm128 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
 = fma towardzero ibm128 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff7ffffffffffffffffffffp-128 : inexact
 = fma upward ibm128 0x8p-152 -0x8p-152 0x3.fffff8p-128 : 0x3.fffff8p-128 : inexact
-fma 0x1p-149 0x1p-149 -0x0.fffffep-126
-= fma downward binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffffp-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffffp-128 : inexact underflow errno-erange-ok
+fma 0x1p-149 0x1p-149 -0x0.fffffep-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffffp-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffffp-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma tonearest binary64 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma towardzero binary64 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff7ffffffep-128 : inexact
@@ -12939,11 +12939,11 @@ fma 0x1p-149 0x1p-149 -0x0.fffffep-126
 = fma tonearest ibm128 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma towardzero ibm128 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff7ffffffffffffffffffffp-128 : inexact
 = fma upward ibm128 0x8p-152 0x8p-152 -0x3.fffff8p-128 : -0x3.fffff7ffffffffffffffffffffp-128 : inexact
-fma 0x1p-149 -0x1p-149 -0x0.fffffep-126
-= fma downward binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x4p-128 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow errno-erange-ok
+fma 0x1p-149 -0x1p-149 -0x0.fffffep-126 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x4p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff80000002p-128 : inexact
 = fma tonearest binary64 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma towardzero binary64 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
@@ -12964,11 +12964,11 @@ fma 0x1p-149 -0x1p-149 -0x0.fffffep-126
 = fma tonearest ibm128 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma towardzero ibm128 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
 = fma upward ibm128 0x8p-152 -0x8p-152 -0x3.fffff8p-128 : -0x3.fffff8p-128 : inexact
-fma 0x1p-149 0x1p-149 0x1p-149
-= fma downward binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 0x8p-152 0x8p-152 : 0x1p-148 : inexact underflow errno-erange-ok
+fma 0x1p-149 0x1p-149 0x1p-149 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 0x8p-152 0x8p-152 : 0x1p-148 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma tonearest binary64 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma towardzero binary64 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact
@@ -12989,11 +12989,11 @@ fma 0x1p-149 0x1p-149 0x1p-149
 = fma tonearest ibm128 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma towardzero ibm128 0x8p-152 0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma upward ibm128 0x8p-152 0x8p-152 0x8p-152 : 0x8.00000000000000000000000004p-152 : inexact
-fma 0x1p-149 -0x1p-149 0x1p-149 missing-errno
-= fma downward binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x0p+0 : inexact underflow errno-erange errno-erange-ok
-= fma tonearest binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x0p+0 : inexact underflow errno-erange errno-erange-ok
-= fma upward binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow errno-erange-ok
+fma 0x1p-149 -0x1p-149 0x1p-149 missing-errno missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x0p+0 : inexact underflow underflow-ok:arg-ibm128 errno-erange errno-erange-ok
+= fma tonearest binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x0p+0 : inexact underflow underflow-ok:arg-ibm128 errno-erange errno-erange-ok
+= fma upward binary32 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 -0x8p-152 0x8p-152 : 0x7.ffffffffffffcp-152 : inexact
 = fma tonearest binary64 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma towardzero binary64 0x8p-152 -0x8p-152 0x8p-152 : 0x7.ffffffffffffcp-152 : inexact
@@ -13014,11 +13014,11 @@ fma 0x1p-149 -0x1p-149 0x1p-149 missing-errno
 = fma tonearest ibm128 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact
 = fma towardzero ibm128 0x8p-152 -0x8p-152 0x8p-152 : 0x7.fffffffffffffffffffffffffep-152 : inexact
 = fma upward ibm128 0x8p-152 -0x8p-152 0x8p-152 : 0x8p-152 : inexact
-fma 0x1p-149 0x1p-149 -0x1p-149 missing-errno
-= fma downward binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x0p+0 : inexact underflow errno-erange errno-erange-ok
-= fma upward binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x0p+0 : inexact underflow errno-erange errno-erange-ok
+fma 0x1p-149 0x1p-149 -0x1p-149 missing-errno missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x0p+0 : inexact underflow underflow-ok:arg-ibm128 errno-erange errno-erange-ok
+= fma upward binary32 0x8p-152 0x8p-152 -0x8p-152 : -0x0p+0 : inexact underflow underflow-ok:arg-ibm128 errno-erange errno-erange-ok
 = fma downward binary64 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact
 = fma tonearest binary64 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact
 = fma towardzero binary64 0x8p-152 0x8p-152 -0x8p-152 : -0x7.ffffffffffffcp-152 : inexact
@@ -13039,11 +13039,11 @@ fma 0x1p-149 0x1p-149 -0x1p-149 missing-errno
 = fma tonearest ibm128 0x8p-152 0x8p-152 -0x8p-152 : -0x8p-152 : inexact
 = fma towardzero ibm128 0x8p-152 0x8p-152 -0x8p-152 : -0x7.fffffffffffffffffffffffffep-152 : inexact
 = fma upward ibm128 0x8p-152 0x8p-152 -0x8p-152 : -0x7.fffffffffffffffffffffffffep-152 : inexact
-fma 0x1p-149 -0x1p-149 -0x1p-149
-= fma downward binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x1p-148 : inexact underflow errno-erange-ok
-= fma tonearest binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow errno-erange-ok
-= fma towardzero binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow errno-erange-ok
-= fma upward binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow errno-erange-ok
+fma 0x1p-149 -0x1p-149 -0x1p-149 missing-underflow:arg-ibm128
+= fma downward binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x1p-148 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma tonearest binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma towardzero binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
+= fma upward binary32 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact underflow underflow-ok:arg-ibm128 errno-erange-ok
 = fma downward binary64 0x8p-152 -0x8p-152 -0x8p-152 : -0x8.0000000000008p-152 : inexact
 = fma tonearest binary64 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact
 = fma towardzero binary64 0x8p-152 -0x8p-152 -0x8p-152 : -0x8p-152 : inexact
@@ -15389,31 +15389,31 @@ fma 0x1.0000000000000000000000000001p-16382 -0x1.0000000000000000000000000001p-6
 = fma tonearest binary128 0x4.0000000000000000000000000004p-16384 -0x4.0000000000000000000000000004p-68 -0x8p+16316 : -0x8p+16316 : inexact
 = fma towardzero binary128 0x4.0000000000000000000000000004p-16384 -0x4.0000000000000000000000000004p-68 -0x8p+16316 : -0x8p+16316 : inexact
 = fma upward binary128 0x4.0000000000000000000000000004p-16384 -0x4.0000000000000000000000000004p-68 -0x8p+16316 : -0x8p+16316 : inexact
-fma 0x1.fffffep-126 0x1.fffffep25 0x1.fffffep127 missing-errno
-= fma downward binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+fma 0x1.fffffep-126 0x1.fffffep25 0x1.fffffep127 missing-errno xfail-rounding:ibm128-libgcc
+= fma downward binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : plus_infty : inexact overflow errno-erange errno-erange-ok
-= fma downward binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+= fma towardzero binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary32 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : plus_infty : xfail:ibm128-libgcc inexact overflow errno-erange errno-erange-ok
+= fma downward binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff00000008p+124 : inexact
-= fma downward intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+= fma towardzero binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary64 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff00000008p+124 : xfail:ibm128-libgcc inexact
+= fma downward intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff0000000001p+124 : inexact
-= fma downward m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+= fma towardzero intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward intel96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff0000000001p+124 : xfail:ibm128-libgcc inexact
+= fma downward m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff0000000001p+124 : inexact
-= fma downward binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+= fma towardzero m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward m68k96 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff0000000001p+124 : xfail:ibm128-libgcc inexact
+= fma downward binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff00000000000000000000008p+124 : inexact
-= fma downward ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
+= fma towardzero binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff00000000000000000000008p+124 : xfail:ibm128-libgcc inexact
+= fma downward ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
 = fma tonearest ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma towardzero ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
-= fma upward ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff000000000000000000004p+124 : inexact
+= fma towardzero ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward ibm128 0x7.fffff8p-128 0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffff000000000000000000004p+124 : xfail:ibm128-libgcc inexact
 fma 0x1.fffffep-126 -0x1.fffffep25 0x1.fffffep127
 = fma downward binary32 0x7.fffff8p-128 -0x3.fffffcp+24 0xf.fffffp+124 : 0xf.ffffep+124 : inexact
 = fma tonearest binary32 0x7.fffff8p-128 -0x3.fffffcp+24 0xf.fffffp+124 : 0xf.fffffp+124 : inexact
@@ -15464,52 +15464,52 @@ fma 0x1.fffffep-126 0x1.fffffep25 -0x1.fffffep127
 = fma tonearest ibm128 0x7.fffff8p-128 0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
 = fma towardzero ibm128 0x7.fffff8p-128 0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.ffffeffffffffffffffffffffcp+124 : inexact
 = fma upward ibm128 0x7.fffff8p-128 0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.ffffeffffffffffffffffffffcp+124 : inexact
-fma 0x1.fffffep-126 -0x1.fffffep25 -0x1.fffffep127 missing-errno
-= fma downward binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : minus_infty : inexact overflow errno-erange errno-erange-ok
+fma 0x1.fffffep-126 -0x1.fffffep25 -0x1.fffffep127 missing-errno xfail-rounding:ibm128-libgcc
+= fma downward binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : minus_infty : xfail:ibm128-libgcc inexact overflow errno-erange errno-erange-ok
 = fma tonearest binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma downward binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff00000008p+124 : inexact
+= fma towardzero binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary32 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma downward binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff00000008p+124 : xfail:ibm128-libgcc inexact
 = fma tonearest binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma downward intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff0000000001p+124 : inexact
+= fma towardzero binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary64 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma downward intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff0000000001p+124 : xfail:ibm128-libgcc inexact
 = fma tonearest intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma downward m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff0000000001p+124 : inexact
+= fma towardzero intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward intel96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma downward m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff0000000001p+124 : xfail:ibm128-libgcc inexact
 = fma tonearest m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma downward binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff00000000000000000000008p+124 : inexact
+= fma towardzero m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward m68k96 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma downward binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff00000000000000000000008p+124 : xfail:ibm128-libgcc inexact
 = fma tonearest binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma downward ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff000000000000000000004p+124 : inexact
+= fma towardzero binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward binary128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma downward ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffff000000000000000000004p+124 : xfail:ibm128-libgcc inexact
 = fma tonearest ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma towardzero ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-= fma upward ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : inexact
-fma 0x1.fffffffffffffp-1022 0x1.fffffffffffffp54 0x1.fffffffffffffp1023 missing-errno
-= fma downward binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+= fma upward ibm128 0x7.fffff8p-128 -0x3.fffffcp+24 -0xf.fffffp+124 : -0xf.fffffp+124 : xfail:ibm128-libgcc inexact
+fma 0x1.fffffffffffffp-1022 0x1.fffffffffffffp54 0x1.fffffffffffffp1023 missing-errno xfail-rounding:ibm128-libgcc
+= fma downward binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma upward binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : plus_infty : inexact overflow errno-erange errno-erange-ok
-= fma downward intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward binary64 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : plus_infty : xfail:ibm128-libgcc inexact overflow errno-erange errno-erange-ok
+= fma downward intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma upward intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff801p+1020 : inexact
-= fma downward m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward intel96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff801p+1020 : xfail:ibm128-libgcc inexact
+= fma downward m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma upward m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff801p+1020 : inexact
-= fma downward binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward m68k96 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff801p+1020 : xfail:ibm128-libgcc inexact
+= fma downward binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma upward binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8000000000000008p+1020 : inexact
-= fma downward ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward binary128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8000000000000008p+1020 : xfail:ibm128-libgcc inexact
+= fma downward ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
-= fma upward ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff80000000000004p+1020 : inexact
+= fma towardzero ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff80000000000004p+1020 : xfail:ibm128-libgcc inexact
 fma 0x1.fffffffffffffp-1022 -0x1.fffffffffffffp54 0x1.fffffffffffffp1023 missing-errno
 = fma downward binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffffp+1020 : inexact
 = fma tonearest binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 0xf.ffffffffffff8p+1020 : 0xf.ffffffffffff8p+1020 : inexact
@@ -15552,27 +15552,27 @@ fma 0x1.fffffffffffffp-1022 0x1.fffffffffffffp54 -0x1.fffffffffffffp1023 missing
 = fma tonearest ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
 = fma towardzero ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff7ffffffffffffcp+1020 : inexact
 = fma upward ibm128 0x7.ffffffffffffcp-1024 0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff7ffffffffffffcp+1020 : inexact
-fma 0x1.fffffffffffffp-1022 -0x1.fffffffffffffp54 -0x1.fffffffffffffp1023 missing-errno
-= fma downward binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : minus_infty : inexact overflow errno-erange errno-erange-ok
+fma 0x1.fffffffffffffp-1022 -0x1.fffffffffffffp54 -0x1.fffffffffffffp1023 missing-errno xfail-rounding:ibm128-libgcc
+= fma downward binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : minus_infty : xfail:ibm128-libgcc inexact overflow errno-erange errno-erange-ok
 = fma tonearest binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma upward binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma downward intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff801p+1020 : inexact
+= fma towardzero binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward binary64 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma downward intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff801p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma upward intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma downward m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff801p+1020 : inexact
+= fma towardzero intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward intel96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma downward m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff801p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma upward m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma downward binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8000000000000008p+1020 : inexact
+= fma towardzero m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward m68k96 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma downward binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8000000000000008p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma upward binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma downward ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff80000000000004p+1020 : inexact
+= fma towardzero binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward binary128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma downward ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff80000000000004p+1020 : xfail:ibm128-libgcc inexact
 = fma tonearest ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma towardzero ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
-= fma upward ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : inexact
+= fma towardzero ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
+= fma upward ibm128 0x7.ffffffffffffcp-1024 -0x7.ffffffffffffcp+52 -0xf.ffffffffffff8p+1020 : -0xf.ffffffffffff8p+1020 : xfail:ibm128-libgcc inexact
 fma 0x1.fffffffffffffffep-16382 0x1.fffffffffffffffep65 0x1.fffffffffffffffep16383 missing-errno
 = fma downward intel96 0x7.fffffffffffffff8p-16384 0x3.fffffffffffffffcp+64 0xf.fffffffffffffffp+16380 : 0xf.fffffffffffffffp+16380 : inexact
 = fma tonearest intel96 0x7.fffffffffffffff8p-16384 0x3.fffffffffffffffcp+64 0xf.fffffffffffffffp+16380 : 0xf.fffffffffffffffp+16380 : inexact
@@ -100,7 +100,14 @@ extern const char doc[];

 #define TEST_COND_ibm128 (MANT_DIG == 106)

-#define TEST_COND_arg_ibm128 (ARG_MANT_DIG == 106)
+/* For non-narrowing tests there is no argument format distinct from
+   the result format, so arg-format conditions are always false (and
+   ARG_PREFIX is not defined).  */
+#ifdef ARG_FLOAT
+# define TEST_COND_arg_ibm128 (ARG_MANT_DIG == 106)
+#else
+# define TEST_COND_arg_ibm128 0
+#endif

 #define TEST_COND_intel96 (MANT_DIG == 64	\
 			   && MIN_EXP == -16381	\
@@ -245,6 +245,7 @@ tests := \
  tst-empty \
  tst-error1 \
  tst-fdset \
+  tst-gethostname \
  tst-getusershell \
  tst-hsearch \
  tst-insremque \
@@ -0,0 +1,118 @@
+/* Basic test for gethostname.
+   Copyright (C) 2024-2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <limits.h>
+#include <sched.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <support/check.h>
+#include <support/namespace.h>
+
+#ifndef HOST_NAME_MAX
+#define HOST_NAME_MAX 64
+#endif
+
+#define MAX_LEN_INCREASE 10
+
+
+static int
+do_test (void)
+{
+  char default_hostname[HOST_NAME_MAX + 1] = "\0";
+  char hostname[HOST_NAME_MAX + 1] = "\0";
+  char generated_hostname[HOST_NAME_MAX + MAX_LEN_INCREASE + 1] = "\0";
+
+  /* sethostname needs support_become_root for namespace privileges. */
+  support_become_root ();
+
+  /* Enter a UTS namespace so sethostname does not affect the host.  */
+#ifdef CLONE_NEWUTS
+  if (unshare (CLONE_NEWUTS) != 0)
+    FAIL_UNSUPPORTED ("unshare (CLONE_NEWUTS): %m");
+#else
+  FAIL_UNSUPPORTED ("CLONE_NEWUTS not supported");
+#endif
+
+  /* Check default hostname is not an empty string.  */
+  TEST_VERIFY_EXIT (gethostname (default_hostname, sizeof (default_hostname))
+		    == 0);
+  TEST_VERIFY (strlen (default_hostname) > 0);
+
+  /* Check that sethostname is permitted in the UTS namespace.  */
+  if (sethostname ("a", 1) != 0)
+    FAIL_UNSUPPORTED ("sethostname: %m");
+  TEST_VERIFY_EXIT (sethostname (default_hostname,
+				 strlen (default_hostname)) == 0);
+
+  /* input: ''
+     expected output: '' */
+  TEST_VERIFY_EXIT (sethostname ("", 0) == 0);
+  TEST_VERIFY (gethostname (hostname, sizeof (hostname)) == 0);
+  TEST_VERIFY (strlen (hostname) == 0);
+
+  /* input: 'a'
+     expected output: 'a' */
+  TEST_VERIFY_EXIT (sethostname ("a", strlen ("a")) == 0);
+  TEST_VERIFY (gethostname (hostname, sizeof (hostname)) == 0);
+  TEST_COMPARE (strlen (hostname), 1);
+  TEST_VERIFY (strcmp (hostname, "a") == 0);
+
+  /* input: abc.def.ghi
+     expected output: abc.def.ghi */
+  TEST_VERIFY_EXIT (sethostname ("abc.def.ghi", strlen ("abc.def.ghi")) == 0);
+  TEST_VERIFY (gethostname (hostname, sizeof (hostname)) == 0);
+  TEST_COMPARE (strlen (hostname), strlen ("abc.def.ghi"));
+  TEST_VERIFY (strcmp (hostname, "abc.def.ghi") == 0);
+
+  /* input: exactly HOST_NAME_MAX
+     expected output: exactly HOST_NAME_MAX, gethostname returns -1,
+     errno set.  */
+  for (int i = 0; i < HOST_NAME_MAX; i++)
+    {
+      /* Generate hostname of length == HOST_NAME_MAX.  */
+      generated_hostname[i] = 'a' + i % 26;
+    }
+  TEST_VERIFY_EXIT (sethostname (generated_hostname,
+                                 strlen (generated_hostname)) == 0);
+  errno = 0;
+  TEST_VERIFY (gethostname (hostname, HOST_NAME_MAX) == -1);
+  TEST_COMPARE (errno, ENAMETOOLONG);
+  TEST_COMPARE (strlen (hostname), HOST_NAME_MAX);
+  TEST_VERIFY (strcmp (hostname, generated_hostname) == 0);
+
+  /* input: longer than HOST_NAME_MAX
+     expected output: sethostname fails, return -1, errno set */
+  for (int i = 0; i < HOST_NAME_MAX + MAX_LEN_INCREASE; i++)
+    {
+      /* Generate hostname LONGER than HOST_NAME_MAX.  */
+      generated_hostname[i] = 'a' + i % 26;
+    }
+  errno = 0;
+  TEST_VERIFY (sethostname (generated_hostname,
+			    strlen (generated_hostname)) == -1);
+  TEST_COMPARE (errno, EINVAL);
+
+  /* Restore default hostname.  */
+  TEST_VERIFY_EXIT (sethostname (default_hostname,
+				 strlen (default_hostname)) == 0);
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -60,6 +60,7 @@ nis_creategroup (const_nis_name group, unsigned int flags)
 	  free (obj->zo_group);
 	  free (obj->zo_owner);
 	  free (obj->zo_name);
+	  free (obj->zo_domain);
 	  free (obj);
 	  return NIS_NOMEMORY;
 	}
@@ -740,11 +740,6 @@ __pthread_create_2_1 (pthread_t *newthread, const pthread_attr_t *attr,
  THREAD_COPY_STACK_GUARD (pd);
 #endif

-  /* Copy the pointer guard value.  */
-#ifdef THREAD_COPY_POINTER_GUARD
-  THREAD_COPY_POINTER_GUARD (pd);
-#endif
-
  /* Setup tcbhead.  */
  tls_setup_tcbhead (pd);

@@ -44,7 +44,7 @@ __pthread_getname_np (pthread_t th, char *buf, size_t len)
  char fname[sizeof (FMT) + 8];
  sprintf (fname, FMT, (unsigned int) pd->tid);

-  int fd = __open64_nocancel (fname, O_RDONLY);
+  int fd = __open64_nocancel (fname, O_RDONLY | O_CLOEXEC);
  if (fd == -1)
    return errno;

@@ -46,7 +46,7 @@ __pthread_setname_np (pthread_t th, const char *name)
  char fname[sizeof (FMT) + 8];
  sprintf (fname, FMT, (unsigned int) pd->tid);

-  int fd = __open64_nocancel (fname, O_RDWR);
+  int fd = __open64_nocancel (fname, O_WRONLY | O_CLOEXEC);
  if (fd == -1)
    return errno;

@@ -192,7 +192,7 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
 	       + gr_mem_cnt * sizeof (uint32_t)
 	       + gr_name_len + gr_passwd_len + gr_mem_len_total);

-      /* If we refill the cache, first assume the reconrd did not
+      /* If we refill the cache, first assume the record did not
 	 change.  Allocate memory on the cache since it is likely
 	 discarded anyway.  If it turns out to be necessary to have a
 	 new record we can still allocate real memory.  */
@@ -224,7 +224,7 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
 		+ h_aliases_cnt * sizeof (uint32_t)
 		+ h_addr_list_cnt * hst->h_length);

-      /* If we refill the cache, first assume the reconrd did not
+      /* If we refill the cache, first assume the record did not
 	 change.  Allocate memory on the cache since it is likely
 	 discarded anyway.  If it turns out to be necessary to have a
 	 new record we can still allocate real memory.  */
@@ -245,7 +245,7 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,

      total = offsetof (struct dataset, strdata) + start * sizeof (int32_t);

-      /* If we refill the cache, first assume the reconrd did not
+      /* If we refill the cache, first assume the record did not
 	 change.  Allocate memory on the cache since it is likely
 	 discarded anyway.  If it turns out to be necessary to have a
 	 new record we can still allocate real memory.  */
@@ -186,7 +186,7 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
 	       + pw_name_len + pw_passwd_len
 	       + pw_gecos_len + pw_dir_len + pw_shell_len);

-      /* If we refill the cache, first assume the reconrd did not
+      /* If we refill the cache, first assume the record did not
 	 change.  Allocate memory on the cache since it is likely
 	 discarded anyway.  If it turns out to be necessary to have a
 	 new record we can still allocate real memory.  */
@@ -180,7 +180,7 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
 		+ s_proto_len
 		+ s_aliases_cnt * sizeof (uint32_t));

-      /* If we refill the cache, first assume the reconrd did not
+      /* If we refill the cache, first assume the record did not
 	 change.  Allocate memory on the cache since it is likely
 	 discarded anyway.  If it turns out to be necessary to have a
 	 new record we can still allocate real memory.  */
@@ -427,12 +427,9 @@ libnss_compat-routines	:= $(addprefix compat-,grp pwd spwd initgroups) \

 install-others		+= $(inst_vardbdir)/Makefile

-# Build static module into libc if requested
 libnss_db-inhibit-o	= $(filter-out .os,$(object-suffixes))
 libnss_compat-inhibit-o	= $(filter-out .os,$(object-suffixes))
-ifeq ($(build-static-nss),yes)
 tests-static		+= tst-nss-static
-endif
 extra-test-objs		+= nss_test1.os nss_test2.os nss_test_errno.os \
 			   nss_test_gai_hv2_canonname.os

@@ -33,10 +33,6 @@
 #include <shadow.h>
 #include <unistd.h>

-#if !defined DO_STATIC_NSS || defined SHARED
-# include <gnu/lib-names.h>
-#endif
-
 #include "nsswitch.h"
 #include "../nscd/nscd_proto.h"
 #include <sysdep.h>
@@ -77,13 +77,11 @@ enum
 extern bool __nss_database_custom[NSS_DBSIDX_max] attribute_hidden;
 #endif

-/* Warning for NSS functions, which don't require dlopen if glibc
-   was built with --enable-static-nss.  */
-#ifdef DO_STATIC_NSS
-# define nss_interface_function(name)
-#else
-# define nss_interface_function(name) static_link_warning (name)
-#endif
+/* NSS lookups can load service modules via dlopen at runtime, so a
+   statically linked program still depends on the shared NSS modules
+   matching the libc it was built against.  Emit the static link
+   warning on the NSS interface functions accordingly.  */
+#define nss_interface_function(name) static_link_warning (name)


 /* Interface functions for NSS.  */
@@ -360,6 +360,7 @@ tests-internal := \
 tests-container := \
  bug-ga2 \
  tst-vfork3 \
+  tst-wordexp-tilde \
  # tests-container

 tests-time64 := \
@@ -0,0 +1,244 @@
+/* Test wordexp tilde expansion with large usernames (BZ 34091).
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <pwd.h>
+#include <stdio.h>
+#include <string.h>
+#include <wordexp.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+
+#include <support/check.h>
+#include <support/support.h>
+#include <support/xunistd.h>
+#include <support/namespace.h>
+
+typedef void (*func_callback_t)(void);
+
+static void
+subprocess_small_stack (void *closure)
+{
+  struct rlimit rl;
+  TEST_COMPARE (getrlimit (RLIMIT_STACK, &rl), 0);
+  rl.rlim_cur = 512 * 1024;
+  TEST_COMPARE (setrlimit (RLIMIT_STACK, &rl), 0);
+
+  func_callback_t func_test = closure;
+  func_test ();
+}
+
+/* Build a string "~<padding>/tail" where <padding> is LEN bytes of the
+   character CH.  The caller must free the result.  */
+static char *
+make_tilde_input (char ch, size_t len, const char *tail)
+{
+  /* ~  +  len  +  /  +  tail  +  \0 */
+  size_t taillen = tail != NULL ? strlen (tail) : 0;
+  size_t total = 1 + len + 1 + taillen + 1;
+  char *buf = xmalloc (total);
+  buf[0] = '~';
+  memset (buf + 1, ch, len);
+  buf[1 + len] = '/';
+  if (tail != NULL)
+    memcpy (buf + 1 + len + 1, tail, taillen);
+  buf[total - 1] = '\0';
+  return buf;
+}
+
+/* Test 1: A very long username must not crash.  The username will not match
+   any real user, so wordexp returns ~<long>/rest.  */
+static void
+test_long_username (void)
+{
+  printf ("info: test_long_username_no_crash\n");
+
+  static const char REST[] = "rest";
+
+  /* 1 MiB username — well beyond any reasonable stack frame.  */
+  const size_t long_len = 1024 * 1024;
+  char *input = make_tilde_input ('A', long_len, REST);
+
+  wordexp_t we = { 0 };
+  int ret = wordexp (input, &we, 0);
+  /* The (non-existent) username is invalid, so wordexp falls back to
+     literal output: ~AAA…/rest.  */
+  TEST_COMPARE (ret, 0);
+  TEST_COMPARE (we.we_wordc, 1);
+
+  /* Verify prefix: '~' followed by long_len 'A's.  */
+  const char *result = we.we_wordv[0];
+  TEST_COMPARE (result[0], '~');
+  TEST_COMPARE (strlen (result),
+	        1 /* ~ */ + long_len + sizeof (REST));
+  for (size_t j = 1; j <= long_len; j++)
+    if (result[j] != 'A')
+      {
+	printf ("  mismatch at position %zu: expected 'A', got '%c'\n",
+		j, result[j]);
+	support_record_failure ();
+	break;
+      }
+  /* Verify the tail after the username.  */
+  TEST_COMPARE_STRING (result + 1 + long_len, "/rest");
+
+  wordfree (&we);
+  free (input);
+}
+
+/* Test 2: A username that just exceeds the default scratch_buffer inline
+   size (1024 bytes) exercises the scratch_buffer_set_array_size growth path
+   without being excessively large.  */
+static void
+test_scratch_buffer_growth (void)
+{
+  printf ("info: test_scratch_buffer_growth\n");
+
+  const size_t len = 2048;
+  char *input = make_tilde_input ('x', len, NULL);
+
+  wordexp_t we = { 0 };
+  int ret = wordexp (input, &we, 0);
+  TEST_COMPARE (ret, 0);
+  TEST_COMPARE (we.we_wordc, 1);
+
+  /* ~xxx…/ — the trailing slash makes a separate empty component, but
+     wordexp merges it into the single token ~xxx…/.  */
+  const char *result = we.we_wordv[0];
+  TEST_COMPARE (result[0], '~');
+  for (size_t j = 1; j <= len; j++)
+    if (result[j] != 'x')
+      {
+	printf ("  mismatch at position %zu\n", j);
+	support_record_failure ();
+	break;
+      }
+  TEST_COMPARE (result[1 + len], '/');
+
+  wordfree (&we);
+  free (input);
+}
+
+/* Test 3: ~root still resolves to the correct home directory through the
+   __getpwnam_r path.  */
+static void
+test_known_user (void)
+{
+  printf ("info: test_known_user\n");
+
+  /* Look up root's home directory for comparison.  */
+  struct passwd *pw = getpwnam ("root");
+  if (pw == NULL || pw->pw_dir == NULL)
+    {
+      printf ("  SKIP: cannot look up root\n");
+      return;
+    }
+
+  char *expected = xasprintf ("%s/file", pw->pw_dir);
+
+  wordexp_t we = { 0 };
+  TEST_COMPARE (wordexp ("~root/file", &we, 0), 0);
+  TEST_COMPARE (we.we_wordc, 1);
+  TEST_COMPARE_STRING (we.we_wordv[0], expected);
+
+  wordfree (&we);
+  free (expected);
+}
+
+/* Test 4: Bare tilde expands to $HOME.  */
+static void
+test_bare_tilde (void)
+{
+  printf ("info: test_bare_tilde\n");
+
+  const char *home = getenv ("HOME");
+  if (home == NULL)
+    {
+      printf ("  SKIP: HOME is not set\n");
+      return;
+    }
+
+  wordexp_t we = { 0 };
+  TEST_COMPARE (wordexp ("~", &we, 0), 0);
+  TEST_COMPARE (we.we_wordc, 1);
+  TEST_COMPARE_STRING (we.we_wordv[0], home);
+
+  wordfree (&we);
+}
+
+/* Test 5: Short non-existent username falls back to literal ~username output,
+   exercising the invalid-login-name path.  */
+static void
+test_unknown_user (void)
+{
+  printf ("info: test_unknown_user\n");
+
+  /* Pick a username that is extremely unlikely to exist.  */
+  wordexp_t we = { 0 };
+  TEST_COMPARE (wordexp ("~no_such_user_xyzzy42", &we, 0), 0);
+  TEST_COMPARE (we.we_wordc, 1);
+  TEST_COMPARE_STRING (we.we_wordv[0], "~no_such_user_xyzzy42");
+
+  wordfree (&we);
+}
+
+/* Test 6: Tilde with username and WRDE_APPEND — exercises parse_tilde's
+   interaction with the WRDE_APPEND word list.  */
+static void
+test_tilde_with_append (void)
+{
+  printf ("info: test_tilde_with_append\n");
+
+  const char *home = getenv ("HOME");
+  if (home == NULL)
+    {
+      printf ("  SKIP: HOME is not set\n");
+      return;
+    }
+
+  wordexp_t we = { 0 };
+  TEST_COMPARE (wordexp ("first", &we, 0), 0);
+
+  TEST_COMPARE (wordexp ("~/path", &we, WRDE_APPEND), 0);
+  TEST_COMPARE (we.we_wordc, 2);
+  TEST_COMPARE_STRING (we.we_wordv[0], "first");
+
+  char *expected = xasprintf ("%s/path", home);
+  TEST_COMPARE_STRING (we.we_wordv[1], expected);
+
+  wordfree (&we);
+  free (expected);
+}
+
+static int
+do_test (void)
+{
+  test_known_user ();
+  test_bare_tilde ();
+  test_unknown_user ();
+  test_tilde_with_append ();
+
+  support_isolate_in_subprocess (subprocess_small_stack,
+				 test_long_username);
+
+  support_isolate_in_subprocess (subprocess_small_stack,
+				 test_scratch_buffer_growth);
+
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -0,0 +1 @@
+root:x:0:
@@ -0,0 +1,3 @@
+passwd: files
+group:  files
+shadow: files
@@ -0,0 +1 @@
+root:x:0:0:root:/root:/bin/sh
@@ -335,17 +335,29 @@ parse_tilde (char **word, size_t *word_length, size_t *max_length,
  else
    {
      /* Look up user name in database to get home directory */
-      char *user = strndupa (&words[1 + *offset], i - (1 + *offset));
-      struct passwd pwd, *tpwd;
-      int result;
+      size_t userlen = i - (1 + *offset);
+      /* tmpbuf contains both the user and the __getpwnam_r working area.  */
      struct scratch_buffer tmpbuf;
      scratch_buffer_init (&tmpbuf);
+      if (!scratch_buffer_set_array_size (&tmpbuf, userlen + 1, 1))
+	return WRDE_NOSPACE;
+      char *user = tmpbuf.data;
+      memcpy (user, &words[1 + *offset], userlen);
+      user[userlen] = '\0';

-      while ((result = __getpwnam_r (user, &pwd, tmpbuf.data, tmpbuf.length,
+      struct passwd pwd, *tpwd;
+      int result;
+      while ((result = __getpwnam_r (user,
+				     &pwd,
+				     tmpbuf.data + userlen + 1,
+				     tmpbuf.length - userlen - 1,
 				     &tpwd)) != 0
 	     && errno == ERANGE)
-	if (!scratch_buffer_grow (&tmpbuf))
-	  return WRDE_NOSPACE;
+	{
+	  if (!scratch_buffer_grow_preserve (&tmpbuf))
+	    return WRDE_NOSPACE;
+	  user = tmpbuf.data;
+	}

      if (result == 0 && tpwd != NULL && pwd.pw_dir)
 	*word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
@@ -108,6 +108,7 @@ tests += \
  tst-ns_name \
  tst-ns_name_compress \
  tst-ns_name_pton \
+  tst-ns_sprintrr \
  tst-res_hconf_reorder \
  tst-res_hnok \
  tst-resolv-aliases \
@@ -122,6 +123,7 @@ tests += \
  tst-resolv-noaaaa \
  tst-resolv-noaaaa-vc \
  tst-resolv-nondecimal \
+  tst-resolv-res_init-failure \
  tst-resolv-res_init-multi \
  tst-resolv-search \
  tst-resolv-semi-failure \
@@ -156,6 +158,7 @@ tests += \
  tst-resolv-ai_idn-nolibidn2 \
  tst-resolv-canonname \
  tst-resolv-getaddrinfo-fqdn \
+  tst-resolv-gethostbyname_r-unaligned \
  tst-resolv-trustad \

 # Needs resolv_context.
@@ -305,8 +308,12 @@ $(objpfx)tst-resolv-byaddr: $(objpfx)libresolv.so $(shared-thread-library)
 $(objpfx)tst-resolv-dns-section: $(objpfx)libresolv.so \
  $(shared-thread-library)
 $(objpfx)tst-resolv-edns: $(objpfx)libresolv.so $(shared-thread-library)
+$(objpfx)tst-resolv-gethostbyname_r-unaligned: \
+  $(objpfx)libresolv.so $(shared-thread-library)
 $(objpfx)tst-resolv-network: $(objpfx)libresolv.so $(shared-thread-library)
 $(objpfx)tst-resolv-res_init: $(objpfx)libresolv.so
+$(objpfx)tst-resolv-res_init-failure: $(objpfx)libresolv.so \
+  $(shared-thread-library)
 $(objpfx)tst-resolv-res_init-multi: $(objpfx)libresolv.so \
  $(shared-thread-library)
 $(objpfx)tst-resolv-res_init-thread: $(objpfx)libresolv.so \
@@ -338,5 +345,6 @@ $(objpfx)tst-ns_name: $(objpfx)libresolv.so
 $(objpfx)tst-ns_name.out: tst-ns_name.data
 $(objpfx)tst-ns_name_compress: $(objpfx)libresolv.so
 $(objpfx)tst-ns_name_pton: $(objpfx)libresolv.so
+$(objpfx)tst-ns_sprintrr: $(objpfx)libresolv.so
 $(objpfx)tst-res_hnok: $(objpfx)libresolv.so
 $(objpfx)tst-p_secstodate: $(objpfx)libresolv.so
@@ -78,6 +78,24 @@ ns_sprintrr(const ns_msg *handle, const ns_rr *rr,
 }
 libresolv_hidden_def (ns_sprintrr)

+/* Writes the class/type symbol NUMBER to *BUF, using the name from
+   *SYMS if possible.  If NUMBER is not found in *SYMS, print the
+   number with PREFIX.  */
+static int
+addsym (const struct res_sym *syms, int number, const char *prefix,
+	char **buf, size_t *buflen)
+{
+  for (; syms->name != NULL; syms++)
+    if (number == syms->number)
+      {
+	T (addstr (" ", 1, buf, buflen));
+	return addstr (syms->name, strlen (syms->name), buf, buflen);
+      }
+  char tmp[20];
+  int len = snprintf (tmp, sizeof (tmp), " %s%d", prefix, number);
+  return addstr (tmp, len, buf, buflen);
+}
+
 /*%
 *	Convert the fields of an RR into presentation format.
 *
@@ -97,7 +115,6 @@ ns_sprintrrf(const u_char *msg, size_t msglen,

 	const char *comment;
 	char tmp[100];
-	char errbuf[40];
 	int len, x;

 	/*
@@ -128,11 +145,21 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 	/*
 	 * TTL, Class, Type.
 	 */
-	T(x = ns_format_ttl(ttl, buf, buflen));
-	addlen(x, &buf, &buflen);
-	len = SPRINTF((tmp, " %s %s", p_class(class), p_type(type)));
-	T(addstr(tmp, len, &buf, &buflen));
-	T(spaced = addtab(x + len, 16, spaced, &buf, &buflen));
+	{
+	  char *start = buf;
+
+	  T (x = ns_format_ttl (ttl, buf, buflen));
+	  addlen (x, &buf, &buflen);
+	  T (addsym (__p_class_syms, class, "CLASS", &buf, &buflen));
+	  if (type == ns_t_a6)
+	    /* A6 is not part of __p_type_syms, which is exported.
+	       Adding A6 there would change its size.  Handle it here.  */
+	    T (addstr (" A6", 3, &buf, &buflen));
+	  else
+	    T (addsym (__p_type_syms, type, "TYPE", &buf, &buflen));
+
+	  T (spaced = addtab(buf - start, 16, spaced, &buf, &buflen));
+	}

 	/*
 	 * RData.
@@ -140,8 +167,9 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 	switch (type) {
 	case ns_t_a:
 	  if (rdlen != (size_t)NS_INADDRSZ)
-			goto formerr;
-		(void) inet_ntop(AF_INET, rdata, buf, buflen);
+		  goto formerr;
+		if (inet_ntop (AF_INET, rdata, buf, buflen) == NULL)
+		  return -1;
 		addlen(strlen(buf), &buf, &buflen);
 		break;

@@ -307,16 +335,18 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 	    }

 	case ns_t_aaaa:
-	  if (rdlen != (size_t)NS_IN6ADDRSZ)
-			goto formerr;
-		(void) inet_ntop(AF_INET6, rdata, buf, buflen);
+		if (rdlen != (size_t)NS_IN6ADDRSZ)
+		  goto formerr;
+		if (inet_ntop (AF_INET6, rdata, buf, buflen) == NULL)
+		  return -1;
 		addlen(strlen(buf), &buf, &buflen);
 		break;

 	case ns_t_loc: {
 		char t[255];

-		/* XXX protocol format checking? */
+		if (rdlen != 16)
+		  goto formerr;
 		(void) loc_ntoa(rdata, t);
 		T(addstr(t, strlen(t), &buf, &buflen));
 		break;
@@ -400,7 +430,8 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 			goto formerr;

 		/* Address. */
-		(void) inet_ntop(AF_INET, rdata, buf, buflen);
+		if (inet_ntop (AF_INET, rdata, buf, buflen) == NULL)
+		  return -1;
 		addlen(strlen(buf), &buf, &buflen);
 		rdata += NS_INADDRSZ;

@@ -434,96 +465,6 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 		break;
 	    }

-	case ns_t_cert: {
-		u_int c_type, key_tag, alg;
-		int n;
-		unsigned int siz;
-		char base64_cert[8192], tmp[40];
-		const char *leader;
-
-		c_type  = ns_get16(rdata); rdata += NS_INT16SZ;
-		key_tag = ns_get16(rdata); rdata += NS_INT16SZ;
-		alg = (u_int) *rdata++;
-
-		len = SPRINTF((tmp, "%d %d %d ", c_type, key_tag, alg));
-		T(addstr(tmp, len, &buf, &buflen));
-		siz = (edata-rdata)*4/3 + 4; /* "+4" accounts for trailing \0 */
-		if (siz > sizeof(base64_cert) * 3/4) {
-			const char *str = "record too long to print";
-			T(addstr(str, strlen(str), &buf, &buflen));
-		}
-		else {
-			len = b64_ntop(rdata, edata-rdata, base64_cert, siz);
-
-			if (len < 0)
-				goto formerr;
-			else if (len > 15) {
-				T(addstr(" (", 2, &buf, &buflen));
-				leader = "\n\t\t";
-				spaced = 0;
-			}
-			else
-				leader = " ";
-
-			for (n = 0; n < len; n += 48) {
-				T(addstr(leader, strlen(leader),
-					 &buf, &buflen));
-				T(addstr(base64_cert + n, MIN(len - n, 48),
-					 &buf, &buflen));
-			}
-			if (len > 15)
-				T(addstr(" )", 2, &buf, &buflen));
-		}
-		break;
-	    }
-
-	case ns_t_tkey: {
-		/* KJD - need to complete this */
-		u_long t;
-		int mode, err, keysize;
-
-		/* Algorithm name. */
-		T(addname(msg, msglen, &rdata, origin, &buf, &buflen));
-		T(addstr(" ", 1, &buf, &buflen));
-
-		/* Inception. */
-		t = ns_get32(rdata);  rdata += NS_INT32SZ;
-		len = SPRINTF((tmp, "%lu ", t));
-		T(addstr(tmp, len, &buf, &buflen));
-
-		/* Expiration. */
-		t = ns_get32(rdata);  rdata += NS_INT32SZ;
-		len = SPRINTF((tmp, "%lu ", t));
-		T(addstr(tmp, len, &buf, &buflen));
-
-		/* Mode , Error, Key Size. */
-		/* Priority, Weight, Port. */
-		mode = ns_get16(rdata);  rdata += NS_INT16SZ;
-		err  = ns_get16(rdata);  rdata += NS_INT16SZ;
-		keysize  = ns_get16(rdata);  rdata += NS_INT16SZ;
-		len = SPRINTF((tmp, "%u %u %u ", mode, err, keysize));
-		T(addstr(tmp, len, &buf, &buflen));
-
-		/* XXX need to dump key, print otherdata length & other data */
-		break;
-	    }
-
-	case ns_t_tsig: {
-		/* BEW - need to complete this */
-		int n;
-
-		T(len = addname(msg, msglen, &rdata, origin, &buf, &buflen));
-		T(addstr(" ", 1, &buf, &buflen));
-		rdata += 8; /*%< time */
-		n = ns_get16(rdata); rdata += INT16SZ;
-		rdata += n; /*%< sig */
-		n = ns_get16(rdata); rdata += INT16SZ; /*%< original id */
-		sprintf(buf, "%d", ns_get16(rdata));
-		rdata += INT16SZ;
-		addlen(strlen(buf), &buf, &buflen);
-		break;
-	    }
-
 	case ns_t_a6: {
 		struct in6_addr a;
 		int pbyte, pbit;
@@ -539,12 +480,14 @@ ns_sprintrrf(const u_char *msg, size_t msglen,

 		/* address suffix: provided only when prefix len != 128 */
 		if (pbit < 128) {
-			if (rdata + pbyte >= edata) goto formerr;
+			unsigned int bytelen = sizeof(a) - pbyte;
+			if (edata - rdata < bytelen) goto formerr;
 			memset(&a, 0, sizeof(a));
-			memcpy(&a.s6_addr[pbyte], rdata, sizeof(a) - pbyte);
-			(void) inet_ntop(AF_INET6, &a, buf, buflen);
+			memcpy(&a.s6_addr[pbyte], rdata, bytelen);
+			if (inet_ntop (AF_INET6, &a, buf, buflen) == NULL)
+			  return -1;
 			addlen(strlen(buf), &buf, &buflen);
-			rdata += sizeof(a) - pbyte;
+			rdata += bytelen;
 		}

 		/* prefix name: provided only when prefix len > 0 */
@@ -557,25 +500,18 @@ ns_sprintrrf(const u_char *msg, size_t msglen,
 		break;
 	    }

-	case ns_t_opt: {
-		len = SPRINTF((tmp, "%u bytes", class));
-		T(addstr(tmp, len, &buf, &buflen));
-		break;
-	    }
-
 	default:
-		snprintf (errbuf, sizeof (errbuf), "unknown RR type %d", type);
-		comment = errbuf;
+		comment = "";
 		goto hexify;
 	}
 	return (buf - obuf);
 formerr:
-	comment = "RR format error";
+	comment = " ; RR format error";
 hexify: {
 	int n, m;
 	char *p;

-	len = SPRINTF((tmp, "\\# %u%s\t; %s", (unsigned)(edata - rdata),
+	len = SPRINTF((tmp, "\\# %u%s%s", (unsigned)(edata - rdata),
 		       rdlen != 0U ? " (" : "", comment));
 	T(addstr(tmp, len, &buf, &buflen));
 	while (rdata < edata) {
@@ -89,7 +89,9 @@
 #include <stdlib.h>

 /* Close all open sockets.  If FREE_ADDR is true, deallocate any
-   separately allocated name server addresses.  */
+   separately allocated name server addresses, detach the extended
+   resolver configuration, and reset the cached extended-state count
+   so subsequent name lookups reinitialize the extended state.  */
 void
 __res_iclose (res_state statp, bool free_addr)
 {
@@ -114,7 +116,10 @@ __res_iclose (res_state statp, bool free_addr)
          }
      }
  if (free_addr)
-    __resolv_conf_detach (statp);
+    {
+      __resolv_conf_detach (statp);
+      statp->_u._ext.nscount = 0;
+    }
 }
 libc_hidden_def (__res_iclose)

@@ -390,8 +390,6 @@ p_fqname(const u_char *cp, const u_char *msg, FILE *file) {
 * that C_ANY is a qclass but not a class.  (You can ask for records of class
 * C_ANY, but you can't have any records of that class in the database.)
 */
-extern const struct res_sym __p_class_syms[];
-libresolv_hidden_proto (__p_class_syms)
 const struct res_sym __p_class_syms[] = {
  {C_IN,    (char *) "IN"},
  {C_CHAOS, (char *) "CHAOS"},
@@ -426,8 +424,6 @@ const struct res_sym __p_update_section_syms[] attribute_hidden = {
 * Names of RR types and qtypes.  The list is incomplete because its
 * size is part of the ABI.
 */
-extern const struct res_sym __p_type_syms[];
-libresolv_hidden_proto (__p_type_syms)
 const struct res_sym __p_type_syms[] = {
  {ns_t_a,      (char *) "A",     (char *) "address"},
  {ns_t_ns,     (char *) "NS",    (char *) "name server"},
@@ -0,0 +1,329 @@
+/* Tests for the ns_sprintrr function.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <arpa/nameser.h>
+
+#include <alloc_buffer.h>
+#include <arpa/inet.h>
+#include <libc-diag.h>
+#include <stdbool.h>
+#include <string.h>
+#include <support/check.h>
+#include <support/next_to_fault.h>
+
+#include <stdio.h>
+
+/* Regions that test_one_record uses for input and output.  */
+static struct support_next_to_fault ntf_in;
+static struct support_next_to_fault ntf_out;
+
+/* This is used by test_one_record to construct the packet.   */
+static const char packet_prefix[] =
+  /* DNS response with one question, one answer record.  */
+  "AA\x81\x80\0\1\0\1\0\0\0\0"
+  /* Question: www.example.org/IN/ANY.  */
+  "\3www\7example\3org\0\0\xff\0\1"
+  /* Response: compression reference.  */
+  "\xc0\x0c";
+
+/* Use ns_sprintrr to format a DNS record (starting with
+   packet_prefix) of type RTYPE, with a record payload of RDATALEN
+   bytes starting at RDATA.  Check successful formatting against
+   EXPECTED.  Try various truncated input and output buffers to catch
+   overreads and buffer overflows, using ntf_in and ntf_out above.  */
+static void
+test_one_record (uint16_t rtype, const char *rdata, size_t rdatalen,
+                 const char *expected)
+{
+  struct rr_header
+  {
+    uint16_t typ;
+    uint16_t cls;
+    uint32_t ttl;
+    uint16_t rdatalen;
+    uint16_t pad;
+  } hdr =
+    {
+      .typ = htons (rtype),
+      .cls = htons (ns_c_in),
+      .ttl = htonl (86400),     /* One day.  */
+      .rdatalen = htons (rdatalen),
+    };
+  enum { hdrlen = offsetof (struct rr_header, pad) };
+  TEST_COMPARE (hdrlen, 10);
+
+  /* Construct the packet from packet_prefix, hdr, and rdata.  */
+  unsigned char packet[512];
+  size_t packetlen;
+  {
+    struct alloc_buffer buf = alloc_buffer_create (packet, sizeof (packet));
+    alloc_buffer_copy_bytes (&buf, packet_prefix, sizeof (packet_prefix) - 1);
+    alloc_buffer_copy_bytes (&buf, &hdr, hdrlen);
+    alloc_buffer_copy_bytes (&buf, rdata, rdatalen);
+    packetlen = sizeof (packet) - alloc_buffer_size (&buf);
+  }
+
+  /* Parse the record.   */
+  ns_msg msg;
+  TEST_COMPARE (ns_initparse (packet, packetlen, &msg), 0);
+  ns_rr rr;
+  TEST_COMPARE (ns_parserr (&msg, ns_s_an, 0, &rr), 0);
+
+  /* Try sizes up to this limit.  Go a bit beyond the expected size to
+     check for errors.  */
+  size_t max_result_size = strlen (expected) + 16;
+
+  bool success = false;
+  for (size_t result_size = 1; result_size <= max_result_size; ++result_size)
+    {
+      char *result_start = ntf_out.buffer + ntf_out.length - result_size;
+      memset (result_start, 'X', result_size);
+
+      /* ns_sprintrr was deprecated in 2.34.  */
+      DIAG_PUSH_NEEDS_COMMENT;
+      DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
+      int ret = ns_sprintrr (&msg, &rr, NULL, NULL, result_start, result_size);
+      DIAG_POP_NEEDS_COMMENT;
+
+      if (ret > 0)
+        {
+          TEST_COMPARE_STRING (result_start, expected);
+          TEST_COMPARE (ret, strlen (expected));
+          success = true;
+        }
+      else
+        {
+          TEST_VERIFY (!success);
+          TEST_COMPARE (ret, -1);
+        }
+    }
+  TEST_VERIFY (success);
+
+  /* Test with truncated RDATA.   */
+  for (size_t rdata_size = 0; rdata_size <= rdatalen; ++rdata_size)
+    {
+      size_t truncated_packet_size = packetlen - rdatalen + rdata_size;
+      unsigned char *packet_start
+        = ((unsigned char *) ntf_in.buffer + ntf_in.length
+           - truncated_packet_size);
+      memcpy (packet_start, packet, truncated_packet_size);
+      /* Patch in the updated RDATA length field.  */
+      uint16_t new_rdatalen = htons (rdata_size);
+      memcpy (packet_start + truncated_packet_size - rdata_size - 2,
+              &new_rdatalen, 2);
+
+      ns_msg msg;
+      TEST_COMPARE (ns_initparse (packet_start, truncated_packet_size, &msg),
+                    0);
+      ns_rr rr;
+      TEST_COMPARE (ns_parserr (&msg, ns_s_an, 0, &rr), 0);
+
+      size_t result_size = strlen (expected) + 1;
+      char *result_start = ntf_out.buffer + ntf_out.length - result_size;
+      memset (result_start, 'X', result_size);
+
+      /* ns_sprintrr was deprecated in 2.34.  */
+      DIAG_PUSH_NEEDS_COMMENT;
+      DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
+      int ret = ns_sprintrr (&msg, &rr, NULL, NULL, result_start, result_size);
+      DIAG_POP_NEEDS_COMMENT;
+
+      /* This flag indicates whether the output is syntactically
+         correct.  In some cases, truncation may still yield a valid
+         payload.  */
+      bool broken = rdata_size < rdatalen;
+      switch (rtype)
+        {
+        case ns_t_wks:
+          /* WKS records use all trailing bytes for the port bitmap.  */
+          broken = rdata_size < 5;
+          break;
+        case ns_t_nsap:
+          /* Uses all bytes that are available.  */
+          broken = false;
+          break;
+        case ns_t_txt:
+          /* Truncation produces a valid payload if it occurs right
+             after a complete string in the TXT payload.  */
+          broken = false;
+          for (size_t pos = 0; pos < rdata_size; )
+            {
+              unsigned int slen = rdata[pos] & 0xff;
+              if (pos + 1 + slen > rdata_size)
+                {
+                  broken = true;
+                  break;
+                }
+              pos += 1 + slen;
+            }
+          break;
+        case ns_t_isdn:
+          /* The second field is optional.  If it is present, it must
+             not be truncated.  */
+          broken = rdata_size < 6 || (rdata_size > 6 && rdata_size < rdatalen);
+          break;
+        case ns_t_a6:
+          /* The first A6 subtest contains a trailing domain name,
+             which is ignored and not formatted.  */
+          if (rdata_size > 0 && rdata[0] == 0)
+            broken = rdata_size < 17;
+          break;
+        case ns_t_cert:
+        case ns_t_tkey:
+        case ns_t_tsig:
+          /* Only generic printing, which does not validate anything.  */
+          broken = false;
+          break;
+        }
+
+      if (broken)
+        {
+          if (strstr (result_start, "RR format error") != NULL)
+            /* No further checks if an error indicator has been added
+               to the output.  */
+            ;
+          else
+            TEST_COMPARE (ret, -1);
+        }
+      else
+        TEST_VERIFY (ret > 0);
+    }
+}
+
+static int
+do_test (void)
+{
+  ntf_in = support_next_to_fault_allocate (512);
+  ntf_out = support_next_to_fault_allocate (256);
+
+#define T(rtype, rdata, expected) \
+  test_one_record (rtype, rdata, sizeof (rdata) - 1, expected)
+  T (ns_t_a, "\xc0\0\2\1", "www.example.org.\t1D IN A\t\t192.0.2.1");
+  T (ns_t_cname, "\4www1\4prod\xc0\x10",
+     "www.example.org.\t1D IN CNAME\twww1.prod.example.org.");
+  T (ns_t_hinfo, "\5first\6second",
+     "www.example.org.\t1D IN HINFO\t\"first\" \"second\"");
+  T (ns_t_isdn, "\5first\6second",
+     "www.example.org.\t1D IN ISDN\t\"first\" \"second\"");
+  /* Bug: Extra space at the end in the text representation of ISDN RRs.  */
+  T (ns_t_isdn, "\5first", "www.example.org.\t1D IN ISDN\t\"first\" ");
+  T (ns_t_soa,
+     "\2ns\xc0\x10\12hostmaster\xc0\x10"
+     "\0\0\0\1\0\0\0\2\0\0\0\3\0\0\0\4\0\0\0\5",
+     "www.example.org.\t1D IN SOA\tns.example.org. hostmaster.example.org. (\n"
+     "\t\t\t\t\t1\t\t; serial\n"
+     "\t\t\t\t\t2S\t\t; refresh\n"
+     "\t\t\t\t\t3S\t\t; retry\n"
+     "\t\t\t\t\t4S\t\t; expiry\n"
+     "\t\t\t\t\t5S )\t\t; minimum\n");
+  T (ns_t_mx, "\0\xa\2mx\xc0\x10",
+     "www.example.org.\t1D IN MX\t10 mx.example.org.");
+  T (ns_t_px, "\0\xa\3px1\xc0\x10\3px2\xc0\x10",
+     "www.example.org.\t1D IN PX\t10 px1.example.org. px2.example.org.");
+  T (ns_t_x25, "\4X.25",
+     "www.example.org.\t1D IN X25\t\"X.25\"");
+  T (ns_t_txt, "\1A\2BC\3DEF",
+     "www.example.org.\t1D IN TXT\t\"A\" \"BC\" \"DEF\"");
+  T (ns_t_nsap, "",
+     "www.example.org.\t1D IN NSAP\t");
+  T (ns_t_nsap, "\1",
+     "www.example.org.\t1D IN NSAP\t01");
+  T (ns_t_nsap, "\1\2",
+     "www.example.org.\t1D IN NSAP\t01.02");
+  T (ns_t_nsap, "\1\2\3",
+     "www.example.org.\t1D IN NSAP\t01.0203");
+  T (ns_t_nsap, "\1\2\3\4",
+     "www.example.org.\t1D IN NSAP\t01.0203.04");
+  T (ns_t_nsap,
+     "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32"
+     "\33\34\35\36\37\40\41\42\43\44\45\46\47\50\51\52\53\54\55\56\57\60\61"
+     "\62\63\64\65\66\67\70\71\72\73\74\75\76\77\100\101\102\103\104\105\106"
+     "\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127"
+     "\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150"
+     "\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+     "\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212"
+     "\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233"
+     "\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254"
+     "\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275"
+     "\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316"
+     "\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
+     "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360"
+     "\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377",
+     "www.example.org.\t1D IN NSAP\t"
+     "01.0203.0405.0607.0809.0A0B.0C0D.0E0F.1011.1213.1415.1617.1819.1A1B"
+     ".1C1D.1E1F.2021.2223.2425.2627.2829.2A2B.2C2D.2E2F.3031.3233.3435.3637"
+     ".3839.3A3B.3C3D.3E3F.4041.4243.4445.4647.4849.4A4B.4C4D.4E4F.5051.5253"
+     ".5455.5657.5859.5A5B.5C5D.5E5F.6061.6263.6465.6667.6869.6A6B.6C6D.6E6F"
+     ".7071.7273.7475.7677.7879.7A7B.7C7D.7E7F.8081.8283.8485.8687.8889.8A8B"
+     ".8C8D.8E8F.9091.9293.9495.9697.9899.9A9B.9C9D.9E9F.A0A1.A2A3.A4A5.A6A7"
+     ".A8A9.AAAB.ACAD.AEAF.B0B1.B2B3.B4B5.B6B7.B8B9.BABB.BCBD.BEBF.C0C1.C2C3"
+     ".C4C5.C6C7.C8C9.CACB.CCCD.CECF.D0D1.D2D3.D4D5.D6D7.D8D9.DADB.DCDD.DEDF"
+     ".E0E1.E2E3.E4E5.E6E7.E8E9.EAEB.ECED.EEEF.F0F1.F2F3.F4F5.F6F7.F8F9.FAFB"
+     ".FCFD.FEFF");
+  T (ns_t_aaaa, "\x20\x01\x0d\xb8\0\0\0\0\0\0\0\0\0\0\x12\x34",
+     "www.example.org.\t1D IN AAAA\t2001:db8::1234");
+  /* Example from RFC 1876.  The loc_ntoa format is different from the
+     official text representation.  */
+  T (ns_t_loc,
+     "\000\063\026\023\211\027\055\320\160\276\025\360\000\230\215\040",
+     "www.example.org.\t1D IN LOC"
+     "\t42 21 54.000 N 71 06 18.000 W -24.00m 30.00m 10000.00m 10.00m");
+  T (ns_t_naptr,
+     "\0\1\0\2\5flags\7service\2.*\5naptr\xc0\x10",
+     "www.example.org.\t1D IN NAPTR\t1 2 \"flags\" \"service\" \".*\""
+     " naptr.example.org.");
+  T (ns_t_srv,
+     "\0\1\0\2\0\x50\4www1\xc0\x10",
+     "www.example.org.\t1D IN SRV\t1 2 80 www1.example.org.");
+  T (ns_t_rp, "\3rp1\xc0\x10\3rp2\xc0\x10",
+     "www.example.org.\t1D IN RP\trp1.example.org. rp2.example.org.");
+  T (ns_t_wks, "\xc0\0\2\1\6\0\0\0\0\0\0\0\0\0\0\200",
+     "www.example.org.\t1D IN WKS\t192.0.2.1 6 ( \n\t\t\t\t80 )");
+  T (ns_t_cert, "\0\1\x04\xd2\0blob",
+     "www.example.org.\t1D IN CERT\t\\# 9 (\n"
+     "\t00 01 04 d2 00 62 6c 6f 62 )\t\t\t; .....blob");
+  T (ns_t_tkey, "\4algo\0\0\0\0\1\0\0\0\2\0\3\0\4"
+     "\0\5\xa1\xa2\xa3\xa4\xa5\0\3\xb1\xb2\xb3",
+     "www.example.org.\t1D IN TYPE249\t\\# 30 (\n"
+     "\t04 61 6c 67 6f 00 00 00 00 01 00 00 00 02 00 03 ; .algo...........\n"
+     "\t00 04 00 05 a1 a2 a3 a4 a5 00 03 b1 b2 b3 )\t; ..............");
+  T (ns_t_tsig, "\4algo\0"
+     "\0\20\xdd\xcd\x64\x10\xe9\x21\x34\x1a\x8e\xe0\xa1\x9a\x30\xfc\x3b\xd1"
+     "\0\2\0\3\0\5other",
+     "www.example.org.\t1D IN TSIG\t\\# 35 (\n"
+     "\t04 61 6c 67 6f 00 00 10 dd cd 64 10 e9 21 34 1a ; .algo.....d..!4.\n"
+     "\t8e e0 a1 9a 30 fc 3b d1 00 02 00 03 00 05 6f 74 ; ....0.;.......ot\n"
+     "\t68 65 72 )\t\t\t\t\t; her");
+  T (ns_t_a6,
+     "\0\x20\x01\x0d\xb8\0\0\0\0\0\0\0\0\0\0\x12\x34\6prefix\xc0\x10",
+     "www.example.org.\t1D IN A6\t0 2001:db8::1234");
+  T (ns_t_a6,
+     "\0\x20\x01\x0d\xb8\0\0\0\0\0\0\0\0\0\0\x12\x35",
+     "www.example.org.\t1D IN A6\t0 2001:db8::1235");
+  T (ns_t_a6, "\200\6prefix\xc0\x10",
+     "www.example.org.\t1D IN A6\t128  prefix.example.org.");
+  T (ns_t_a6, "\x20\0\0\0\0\0\0\0\0\0\0\x12\x36\6prefix\xc0\x10",
+     "www.example.org.\t1D IN A6\t32 ::1236 prefix.example.org.");
+#undef T
+
+  support_next_to_fault_free (&ntf_in);
+  support_next_to_fault_free (&ntf_out);
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -0,0 +1,161 @@
+/* Test for BZ #18287.
+   This test verifies that gethostbyname_r correctly accounts for pointer
+   alignment padding when calculating the remaining buffer size.
+   Copyright (C) 2026 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <netdb.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <support/check.h>
+#include <support/check_nss.h>
+#include <support/resolv_test.h>
+#include <support/support.h>
+#include <support/xmemstream.h>
+
+static const char host_name[] = "foo.site.example";
+
+/* Prepare big enough answer to trigger buffer overflow.  */
+static void
+response (const struct resolv_response_context *ctx,
+          struct resolv_response_builder *b,
+          const char *qname, uint16_t qclass, uint16_t qtype)
+{
+  if (strcmp (qname, host_name) == 0 && qtype == T_A)
+    {
+      struct resolv_response_flags flags = { };
+      resolv_response_init (b, flags);
+      resolv_response_add_question (b, qname, qclass, qtype);
+      resolv_response_section (b, ns_s_an);
+
+      for (int i = 0; i <= 60; i++)
+        {
+          char last_ch = (char) i;
+          char addr_ipv4[4] = { 127, 126, 125, last_ch };
+          resolv_response_open_record (b, qname, qclass, T_A, 0x12345678);
+          resolv_response_add_data (b, addr_ipv4, sizeof (addr_ipv4));
+          resolv_response_close_record (b);
+        }
+    }
+}
+
+/* Test gethostbyname_r with a specified buffer size and alignment.
+   Returns true if the buffer is sufficient, false if it's too small.  */
+static bool
+query_host (size_t size, size_t align)
+{
+  struct hostent ret;
+  struct hostent *result = NULL;
+  int err;
+
+  /* Allocate memory for buffer, alignment padding, and a 64-byte checking
+     area.  */
+  size_t total_alloc = size + align + 64;
+  unsigned char *raw_buf = xmalloc (total_alloc);
+
+  /* Fill the tail of the buffer with 0xAA to detect overflows below.  */
+  memset (raw_buf, 0, size + align);
+  memset (raw_buf + size + align, 0xAA, 64);
+
+  char *ptr = (char *) raw_buf + align;
+
+  int res = gethostbyname_r (host_name, &ret, ptr, size, &result, &err);
+
+  /* Verify that the overflow guard region remains unchanged.  */
+  for (int i = 0; i < 64; i++)
+    if (raw_buf[size + align + i] != 0xAA)
+      FAIL_EXIT1 ("Buffer overflow was detected! (align=%zu, size=%zu)",
+                  align, size);
+
+  bool is_sufficient = false;
+
+  if (res == 0 && result != NULL)
+    {
+      /* Generate the expected response to satisfy check_hostent.  */
+      struct xmemstream expected;
+      xopen_memstream (&expected);
+
+      fprintf (expected.out, "name: %s\n", host_name);
+      for (int i = 0; i <= 60; i++)
+        fprintf (expected.out, "address: 127.126.125.%d\n", i);
+
+      xfclose_memstream (&expected);
+      check_hostent (host_name, &ret, expected.buffer);
+      free (expected.buffer);
+      is_sufficient = true; /* Buffer is sufficient.  */
+    }
+  else if (res == ERANGE && err == NETDB_INTERNAL)
+    is_sufficient = false; /* Buffer is too small.  */
+  else
+    FAIL_EXIT1 ("gethostbyname_r failed unexpectedly: res=%d, err=%d",
+                res, err);
+
+  free (raw_buf);
+  return is_sufficient;
+}
+
+static int
+do_test (void)
+{
+  struct resolv_test *aux = resolv_test_start
+    ((struct resolv_redirect_config)
+     {
+       .response_callback = response,
+     });
+
+  int lower_bound = 512;
+  int upper_bound = 2048;
+
+  TEST_COMPARE (query_host (lower_bound, 0), false);
+  TEST_COMPARE (query_host (upper_bound, 0), true);
+
+  /* Finding the smallest hostent buffer size.  */
+  while (upper_bound != lower_bound + 1)
+    {
+      int size = (lower_bound + upper_bound) / 2;
+      if (query_host (size, 0))
+        upper_bound = size;
+      else
+        lower_bound = size;
+    }
+
+  printf ("info: Boundary found. lower_bound=%d, upper_bound=%d\n",
+          lower_bound, upper_bound);
+
+  TEST_COMPARE (query_host (lower_bound, 0), false);
+  TEST_COMPARE (query_host (upper_bound, 0), true);
+
+  /* Trigger the vulnerability.
+     Test all misalignments (1-7 bytes).  Note that it is expected that
+     for certain alignments, the required buffer size increases.  This
+     happens because gethostbyname_r applies internal padding to align
+     pointers, which consumes available space.  Therefore, a patched glibc
+     safely returns true (success) or false (ERANGE) depending on this
+     padding.  A vulnerable glibc will fail to account for alignment
+     padding, overflow the buffer, and cause a test failure.  */
+  for (size_t align = 1; align < 8; align++)
+    query_host (upper_bound, align);
+
+  resolv_test_end (aux);
+
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -0,0 +1,109 @@
+/* Test that name lookups do not crash after a failing res_init call.
+   Copyright The GNU Toolchain Authors.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* When res_init is called on a thread whose resolver state has
+   already been initialized, it unconditionally invokes
+   __res_iclose(&_res, true) before __res_vinit.  __res_iclose used
+   to NULL every _u._ext.nsaddrs[ns] without resetting
+   _u._ext.nscount, breaking the invariant that
+   __res_context_send's validation loop relies on.  If __res_vinit
+   then failed (for example, because fopen("/etc/resolv.conf")
+   returned EMFILE), the resolver state was left with
+   _u._ext.nscount > 0 and _u._ext.nsaddrs[*] == NULL.  The next
+   name lookup walked the validation loop and dereferenced NULL in
+   sock_eq.
+
+   This test reproduces the crash:
+     1. perform a name lookup so __res_context_send populates
+        _u._ext.nsaddrs[] and sets _u._ext.nscount;
+     2. drop RLIMIT_NOFILE so fopen("/etc/resolv.conf") fails with
+        EMFILE on the next call;
+     3. call res_init, which must report failure;
+     4. perform another name lookup, which must not crash.  */
+
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <sys/resource.h>
+
+#include <support/check.h>
+#include <support/resolv_test.h>
+#include <support/xunistd.h>
+
+static void
+response (const struct resolv_response_context *ctx,
+	  struct resolv_response_builder *b,
+	  const char *qname, uint16_t qclass, uint16_t qtype)
+{
+  resolv_response_init (b, (struct resolv_response_flags) { 0 });
+  resolv_response_add_question (b, qname, qclass, qtype);
+  resolv_response_section (b, ns_s_an);
+  resolv_response_open_record (b, qname, qclass, qtype, 0);
+  if (qtype == T_A)
+    {
+      const char ipv4[4] = { 192, 0, 2, 1 };
+      resolv_response_add_data (b, ipv4, sizeof (ipv4));
+    }
+  resolv_response_close_record (b);
+}
+
+static int
+do_test (void)
+{
+  struct resolv_test *aux = resolv_test_start
+    ((struct resolv_redirect_config) { .response_callback = response });
+
+  /* Initial lookup.  This drives __res_context_send through its init
+     block, which allocates _u._ext.nsaddrs[] and sets
+     _u._ext.nscount to _res.nscount.  */
+  struct hostent *h = gethostbyname ("primer.example");
+  TEST_VERIFY_EXIT (h != NULL);
+
+  /* Drop RLIMIT_NOFILE so that the next fopen of /etc/resolv.conf
+     inside __resolv_conf_load fails with EMFILE.  Already-open
+     descriptors (including those held by the resolv test harness)
+     remain valid; only new descriptor allocations are blocked.  */
+  struct rlimit rl;
+  TEST_COMPARE (getrlimit (RLIMIT_NOFILE, &rl), 0);
+  rlim_t saved_cur = rl.rlim_cur;
+  rl.rlim_cur = 3;
+  TEST_COMPARE (setrlimit (RLIMIT_NOFILE, &rl), 0);
+
+  /* res_init must report failure: __res_iclose has already cleared
+     the extended state, __res_vinit then fails to reload
+     /etc/resolv.conf.  */
+  TEST_COMPARE (res_init (), -1);
+
+  /* The repro: without the fix in __res_iclose, this call would
+     enter __res_context_send's validation loop with stale
+     _u._ext.nscount and NULL _u._ext.nsaddrs[0], dereference NULL
+     in sock_eq, and SIGSEGV.  We do not care whether the lookup
+     succeeds (it will likely fail because socket() also returns
+     EMFILE), only that it returns without crashing.  */
+  (void) gethostbyname ("after.example");
+
+  /* Restore the descriptor limit before resolv_test_end so its
+     cleanup work is not constrained.  */
+  rl.rlim_cur = saved_cur;
+  TEST_COMPARE (setrlimit (RLIMIT_NOFILE, &rl), 0);
+
+  resolv_test_end (aux);
+  return 0;
+}
+
+#include <support/test-driver.c>
@@ -1510,7 +1510,7 @@
 	    }								\
 									\
 	  if (_FP_EXPBIAS_##fs + (rsize) - 1 < _FP_EXPMAX_##fs		\
-	      && (rsigned)						\
+	      && (rsigned) != 0						\
 	      && X##_s							\
 	      && X##_e == _FP_EXPBIAS_##fs + (rsize) - 1)		\
 	    {								\
@@ -1555,7 +1555,7 @@
 				  _FP_FRACBITS_##fs);			\
 	      _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize));			\
 	    }								\
-	  if ((rsigned) && X##_s)					\
+	  if ((rsigned) != 0 && X##_s)					\
 	    (r) = -(r);							\
 	  if ((rsigned) == 2 && X##_e >= _FP_EXPBIAS_##fs + (rsize) - 1) \
 	    {								\
@@ -327,6 +327,7 @@ tests := \
  tst-scanf-binary-gnu11 \
  tst-scanf-binary-gnu89 \
  tst-scanf-bz27650 \
+  tst-scanf-bz34208 \
  tst-scanf-intn \
  tst-scanf-nan \
  tst-scanf-round \
@@ -351,6 +352,7 @@ tests := \
  tst-vfprintf-width-prec-alloc \
  tst-vfscanf-bz34008 \
  tst-wc-printf \
+  tst-wscanf-bz34208 \
  tstdiomisc \
  tstgetln \
  tstscanf \
@@ -305,7 +305,7 @@ do_test (int argc, char *argv[])

  mtrace ();

-  if (PREC && printf ("prec:%i\n", PREC) < 0)
+  if (PREC != 0 && printf ("prec:%i\n", PREC) < 0)
    {
      perror ("printf");
      return EXIT_FAILURE;
@@ -0,0 +1,103 @@
+/* Test scanf pushback for incomplete nan/inf inputs (BZ #34208).
+   Copyright (C) 2026 The GNU Toolchain Authors.
+   This file is part of the GNU C Library.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <array_length.h>
+#include <stdio.h>
+#include <support/check.h>
+#include <wchar.h>
+
+#ifdef TEST_WCHAR
+# define CHAR_T wchar_t
+# define WINT_T wint_t
+# define FSCANF fwscanf
+# define FPUTC fputwc
+# define FGETC fgetwc
+# define EOF_VALUE WEOF
+# define L_(Str) L ## Str
+#else
+# define CHAR_T char
+# define WINT_T int
+# define FSCANF fscanf
+# define FPUTC fputc
+# define FGETC fgetc
+# define EOF_VALUE EOF
+# define L_(Str) Str
+#endif
+
+#define SCAN_FORMAT L_("%e")
+
+static const float sentinel = -123.0f;
+
+struct test
+{
+  const CHAR_T *input;
+  long int expected_offset;
+  const CHAR_T *expected_rest;
+};
+
+static const struct test tests[] =
+  {
+    /* Original reproducer.  The "[" is read while looking for the
+       second "n" in "nan", so it must be pushed back.  */
+    { L_("+NA[..z"), 3, L_("[..z") },
+
+    /* Mismatch while matching "nan(...)", "inf" and "infinity" must be
+       pushed back.  */
+    { L_("nan(@X"), 4, L_("@X") },
+    { L_("iX"), 1, L_("X") },
+    { L_("infiX"), 4, L_("X") },
+  };
+
+static void
+do_one_test (const struct test *test)
+{
+  FILE *fp = tmpfile ();
+  TEST_VERIFY_EXIT (fp != NULL);
+
+  for (const CHAR_T *p = test->input; *p != '\0'; p++)
+    TEST_COMPARE (FPUTC (*p, fp), (WINT_T) *p);
+
+  TEST_COMPARE (fseek (fp, 0, SEEK_SET), 0);
+
+  float value = sentinel;
+  TEST_COMPARE (FSCANF (fp, SCAN_FORMAT, &value), 0);
+  TEST_COMPARE (ftell (fp), test->expected_offset);
+  TEST_VERIFY (value == sentinel);
+
+  for (const CHAR_T *p = test->expected_rest; *p != '\0'; p++)
+    TEST_COMPARE (FGETC (fp), (WINT_T) *p);
+
+  TEST_COMPARE (FGETC (fp), EOF_VALUE);
+  TEST_VERIFY (feof (fp));
+  TEST_VERIFY (! ferror (fp));
+
+  TEST_COMPARE (fclose (fp), 0);
+}
+
+static int
+do_test (void)
+{
+  for (size_t i = 0; i < array_length (tests); i++)
+    {
+      printf ("info: case %zu\n", i);
+      do_one_test (&tests[i]);
+    }
+
+  return 0;
+}
+
+#include <support/test-driver.c>
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`cp $B/elf/tst-ptrguard-static-dlopen-mod.so $L/tst-ptrguard-static-dlopen-mod.so`