The recent fexecve changes broke the build on (at least) alpha (maybe
other configurations, that was the first breakage I saw in my
build-many-glibcs.py run):
In file included from ../sysdeps/unix/sysv/linux/alpha/sysdep.h:29:0,
from ../sysdeps/alpha/nptl/tls.h:31,
from ../include/errno.h:25,
from ../sysdeps/unix/sysv/linux/fexecve.c:18:
../sysdeps/unix/sysv/linux/fexecve.c: In function 'fexecve':
../sysdeps/unix/alpha/sysdep.h:203:10: error: 'sizeof' on array function parameter 'argv' will return size of 'char * const*' [-Werror=sizeof-array-argument]
(sizeof(arg) == 4 ? (long)(int)(long)(arg) : (long)(arg))
^
../sysdeps/unix/alpha/sysdep.h:302:26: note: in expansion of macro 'syscall_promote'
register long _tmp_18 = syscall_promote (arg3); \
^~~~~~~~~~~~~~~
../sysdeps/unix/alpha/sysdep.h:173:2: note: in expansion of macro 'inline_syscall5'
inline_syscall##nr(__NR_##name, args); \
^~~~~~~~~~~~~~
../sysdeps/unix/sysv/linux/alpha/sysdep.h:85:2: note: in expansion of macro 'INLINE_SYSCALL1'
INLINE_SYSCALL1(name, nr, args); \
^~~~~~~~~~~~~~~
../sysdeps/unix/sysv/linux/fexecve.c:42:3: note: in expansion of macro 'INLINE_SYSCALL'
INLINE_SYSCALL (execveat, 5, fd, "", argv, envp, AT_EMPTY_PATH);
^~~~~~~~~~~~~~
../sysdeps/unix/sysv/linux/fexecve.c:33:30: note: declared here
fexecve (int fd, char *const argv[], char *const envp[])
^~~~
This patch fixes this similarly to previous fixes for such issues: use
&argv[0] and &envp[0] as the syscall macro arguments. Tested
(compilation only) for alpha-linux-gnu with build-many-glibcs.py.
* sysdeps/unix/sysv/linux/fexecve.c (fexecve) [__NR_execveat]:
Explicitly take address of first element of array arguments in
call to INLINE_SYSCALL.
Add a trace for logf. This is a reduced trace based on 2.8 billion
samples extracted from wrf_r.
* benchtests/Makefile: Add logf benchmark.
* benchtests/logf-inputs: Add reduced trace from wrf_r.
Add a trace for expf. This is a reduced trace based on 2.4 billion
samples extracted from wrf_r.
* benchtests/Makefile: Add expf benchmark.
* benchtests/expf-inputs: Add reduced trace from wrf_r.
Add unwind info to __libc_start_main so that unwinding continues one
extra level to _start. Similarly add unwind info to backtrace.
Given many targets require this, do this in a general way.
* csu/Makefile: Add -funwind-tables to libc-start.c.
* debug/Makefile: Add -funwind-tables to backtrace.c.
* sysdeps/aarch64/Makefile: Remove CFLAGS-backtrace.c.
* sysdeps/arm/Makefile: Likewise.
* sysdeps/i386/Makefile: Likewise.
* sysdeps/m68k/Makefile: Likewise.
* sysdeps/mips/Makefile: Likewise.
* sysdeps/nios2/Makefile: Likewise.
* sysdeps/sh/Makefile: Likewise.
* sysdeps/sparc/Makefile: Likewise.
This patch adds benchtests for the trunc and truncf functions. The
inputs listed are fairly arbitrary; I do not assert they are
representative of any particular application.
* benchtests/Makefile (bench-math): Add trunc and truncf.
(CFLAGS-bench-trunc.c): New variable.
(CFLAGS-bench-truncf.c): Likewise.
* benchtests/trunc-inputs: New file.
* benchtests/truncf-inputs: Likewise.
As per the section "3.1.4.2 Alignment Interrupts" of the "POWER8 Processor
User's Manual for the Single-Chip Module", alignment interrupt is reported
for misaligned stores in Caching-inhibited storage. As memset is used in
some drivers for DMA (like xorg), this patch avoids misaligned stores for
sizes less than 8 in memset.
This patch fixes a problem on powerpc64le that I missed in initial
testing of my last patch to ldbl-opt. In the specific case of
powerpc64le, the weak aliases for exp10l and remainderl do not get
defined in the generic wrappers because of how those wrappers
undefine and redefine weak_alias. This patch restores those aliases
in the ldbl-opt code.
Tested (compilation only) for powerpc64le with build-many-glibcs.py.
* sysdeps/ieee754/ldbl-opt/w_exp10l_compat.c [LIBM_SVID_COMPAT &&
!LONG_DOUBLE_COMPAT (libm, GLIBC_2_1)] (weak_alias): Undefine and
redefine.
[LIBM_SVID_COMPAT && !LONG_DOUBLE_COMPAT (libm, GLIBC_2_1)]
(exp10l): Define as weak alias.
* sysdeps/ieee754/ldbl-opt/w_remainderl_compat.c [LIBM_SVID_COMPAT
&& !LONG_DOUBLE_COMPAT (libm, GLIBC_2_0)] (weak_alias): Undefine
and redefine.
[LIBM_SVID_COMPAT && !LONG_DOUBLE_COMPAT (libm, GLIBC_2_0)]
(remainderl): Define as weak alias.
This patch converts libm function implementations in math/ from using
weak_alias to using libm_alias_ldouble to define public function
names, in cases where it would be appropriate to define _Float128 /
_Float64x aliases for those functions as well (in cases where either
or both of those types exist and have the same ABI as long double).
This eliminates many ldbl-opt wrappers round these function
implementations.
Tested for x86_64, and with build-many-glibcs.py. All installed
stripped shared libraries are unchanged except for libm.so on
powerpc64le. As noted for a previous patch, powerpc64le's use of
ldbl-opt means various long double functions get defined using
long_double_symbol which gives them an explicit symbol version in the
object files, and this patch results in some such functions using
weak_alias instead (because powerpc64le never had a previous version
of these functions for long double = double); both produce a valid
libm.so with the same public symbols at the same versions, but macros
expanding to call weak_alias is cleaner in this case.
* math/s_fmal.c: Include <libm-alias-ldouble.h>.
(fmal): Define using libm_alias_ldouble.
* math/w_acoshl_compat.c: Include <libm-alias-ldouble.h>.
(acoshl): Define using libm_alias_ldouble.
* math/w_acosl_compat.c: Include <libm-alias-ldouble.h>.
(acosl): Define using libm_alias_ldouble.
* math/w_asinl_compat.c: Include <libm-alias-ldouble.h>.
(asinl): Define using libm_alias_ldouble.
* math/w_atan2l_compat.c: Include <libm-alias-ldouble.h>.
(atan2l): Define using libm_alias_ldouble.
* math/w_atanhl_compat.c: Include <libm-alias-ldouble.h>.
(atanhl): Define using libm_alias_ldouble.
* math/w_coshl_compat.c: Include <libm-alias-ldouble.h>.
(coshl): Define using libm_alias_ldouble.
* math/w_exp10l_compat.c: Include <libm-alias-ldouble.h>.
(exp10l): Define using libm_alias_ldouble.
* math/w_exp2l_compat.c: Include <libm-alias-ldouble.h>.
(exp2l): Define using libm_alias_ldouble.
* math/w_expl_compat.c: Include <libm-alias-ldouble.h>.
(expl): Define using libm_alias_ldouble.
* math/w_fmodl_compat.c: Include <libm-alias-ldouble.h>.
(fmodl): Define using libm_alias_ldouble.
* math/w_hypotl_compat.c: Include <libm-alias-ldouble.h>.
(hypotl): Define using libm_alias_ldouble.
* math/w_j0l_compat.c: Include <libm-alias-ldouble.h>.
(j0l): Define using libm_alias_ldouble.
(y0l): Likewise.
* math/w_j1l_compat.c: Include <libm-alias-ldouble.h>.
(j1l): Define using libm_alias_ldouble.
(y1l): Likewise.
* math/w_jnl_compat.c: Include <libm-alias-ldouble.h>.
(jnl): Define using libm_alias_ldouble.
(ynl): Likewise.
* math/w_log10l_compat.c: Include <libm-alias-ldouble.h>.
(log10l): Define using libm_alias_ldouble.
* math/w_log2l_compat.c: Include <libm-alias-ldouble.h>.
(log2l): Define using libm_alias_ldouble.
* math/w_logl_compat.c: Include <libm-alias-ldouble.h>.
(logl): Define using libm_alias_ldouble.
* math/w_powl_compat.c: Include <libm-alias-ldouble.h>.
(powl): Define using libm_alias_ldouble.
* math/w_remainderl_compat.c: Include <libm-alias-ldouble.h>.
(remainderl): Define using libm_alias_ldouble.
* math/w_sinhl_compat.c: Include <libm-alias-ldouble.h>.
(sinhl): Define using libm_alias_ldouble.
* math/w_sqrtl_compat.c: Include <libm-alias-ldouble.h>.
(sqrtl): Define using libm_alias_ldouble.
* math/w_tgammal_compat.c: Include <libm-alias-ldouble.h>.
(tgammal): Define using libm_alias_ldouble.
* sysdeps/ieee754/ldbl-opt/w_exp10l_compat.c [LIBM_SVID_COMPAT]
(exp10l): Do not use long_double_symbol here.
* sysdeps/ieee754/ldbl-opt/w_remainderl_compat.c
[LIBM_SVID_COMPAT] (remainderl): Likewise.
* sysdeps/ieee754/ldbl-opt/s_fmal.c: Remove.
* sysdeps/ieee754/ldbl-opt/w_acoshl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_acosl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_asinl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_atan2l_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_atanhl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_coshl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_expl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_fmodl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_hypotl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_j0l_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_j1l_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_jnl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log10l_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log2l_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_logl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_powl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_sinhl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_sqrtl_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_tgammal_compat.c: Likewise.
eXecute-Only Memory (XOM) is a protection mechanism against some ROP
attacks. XOM sets the code as executable and unreadable, so the access
to any data, like literal pools, in the code section causes the fault
with XOM. The compiler can disable literal pools for C source files,
but not for assembly files, so I use movz/movk instead of literal pools
in start.S for XOM.
I add MOVL macro with movz/movk instructions like movl pseudo-instruction
in armasm, and use the macro instead of literal pools.
* sysdeps/aarch64/start.S: Use MOVL instead of literal pools.
* sysdeps/aarch64/sysdep.h (MOVL): Add MOVL macro.
The compare_strings.py option unconditionally generates a graph PNG
image of the input data, which can be unnecessary and slow. Put this
behind an optional flag -g.
* benchtests/scripts/compare_strings.py: New option -g.
(draw_graph): Print a message that a graph is being generated.
(process_results): Generate graph only if -g is passed.
(main): Process option -g.
Make the column widths for the outputs fixed so that they look a
little less messy. They will still look bad with lots of IFUNCs (like
on x86) but it's still a step forward.
* benchtests/scripts/compare_strings.py (process_results):
Better spacing for output.
Make the script more usable by adding proper command line options
along with a way to query the options. The script is capable of doing
a bunch of things right now like choosing a base for comparison,
choosing to generate graphs, etc. and they should be accessible via
command line switches.
* benchtests/scripts/compare_strings.py: Use argparse.
* benchtests/README: Document existence of compare_strings.py.
This patch converts libm function implementations in math/ from using
weak_alias to using libm_alias_double to define public function names,
in cases where it would be appropriate to define _Float64 / _Float32x
aliases for those functions as well. This eliminates many
NO_LONG_DOUBLE conditionals and ldbl-opt wrappers round these function
implementations.
Tested for x86_64. Also tested with build-many-glibcs.py. Binary
differences seen are that the different order in which remainder and
drem symbols get defined as a result of this patch (the same source
file defines the same aliases, but in a different order of definition)
changes the order of symbols in the final libm.so when long double =
double, and for ldbl-opt configurations, the compat symbols for Bessel
functions were previously defined by e.g. "compat_symbol (libm, j0,
j0l, GLIBC_2_0)", which declares j0l as a compat symbol based on j0
and so makes j0l weak because j0 is weak, and are now defined
(indirectly via the relevant macros) based on e.g. __j0, so are no
longer weak because __j0 isn't weak.
* math/s_fma.c: Include <libm-alias-double.h>.
(fma): Define using libm_alias_double.
* math/s_nextafter.c: Include <libm-alias-double.h>.
(nextafter): Define using libm_alias_double.
* math/w_acos_compat.c: Include <libm-alias-double.h>.
(acos): Define using libm_alias_double.
* math/w_acosh_compat.c: Include <libm-alias-double.h>.
(aocsh): Define using libm_alias_double.
* math/w_asin_compat.c: Include <libm-alias-double.h>.
(asin): Define using libm_alias_double.
* math/w_atan2_compat.c: Include <libm-alias-double.h>.
(atan2): Define using libm_alias_double.
* math/w_atanh_compat.c: Include <libm-alias-double.h>.
(atanh): Define using libm_alias_double.
* math/w_cosh_compat.c: Include <libm-alias-double.h>.
(cosh): Define using libm_alias_double.
* math/w_exp10_compat.c: Include <libm-alias-double.h>.
(exp10): Define using libm_alias_double.
* math/w_exp2_compat.c: Include <libm-alias-double.h>.
(exp2): Define using libm_alias_double.
* math/w_exp_compat.c: Include <libm-alias-double.h>.
(exp): Define using libm_alias_double.
* math/w_fmod_compat.c: Include <libm-alias-double.h>.
(fmod): Define using libm_alias_double.
* math/w_hypot_compat.c: Include <libm-alias-double.h>.
(hypot): Define using libm_alias_double.
* math/w_j0_compat.c: Include <libm-alias-double.h>.
(j0): Define using libm_alias_double.
(y0): Likewise.
* math/w_j1_compat.c: Include <libm-alias-double.h>.
(j1): Define using libm_alias_double.
(y1): Likewise.
* math/w_jn_compat.c: Include <libm-alias-double.h>.
(jn): Define using libm_alias_double.
(yn): Likewise.
* math/w_log10_compat.c: Include <libm-alias-double.h>.
(log10): Define using libm_alias_double.
* math/w_log2_compat.c: Include <libm-alias-double.h>.
(log2): Define using libm_alias_double.
* math/w_log_compat.c: Include <libm-alias-double.h>.
(log): Define using libm_alias_double.
* math/w_pow_compat.c: Include <libm-alias-double.h>.
(pow): Define using libm_alias_double.
* math/w_remainder_compat.c: Include <libm-alias-double.h>.
(remainder): Define using libm_alias_double.
* math/w_sinh_compat.c: Include <libm-alias-double.h>.
(sinh): Define using libm_alias_double.
* math/w_sqrt_compat.c: Include <libm-alias-double.h>.
(sqrt): Define using libm_alias_double.
* math/w_tgamma_compat.c: Include <libm-alias-double.h>.
(tgamma): Define using libm_alias_double.
* sysdeps/ieee754/ldbl-opt/s_nextafter.c [LONG_DOUBLE_COMPAT(libm,
GLIBC_2_0)] (nextafterl): Do not define compat symbol here.
* sysdeps/ieee754/ldbl-opt/w_exp10_compat.c
[LONG_DOUBLE_COMPAT(libm, GLIBC_2_1)] (exp10l): Likewise.
* sysdeps/ieee754/ldbl-opt/w_remainder_compat.c
[LONG_DOUBLE_COMPAT(libm, GLIBC_2_0)] (remainderl): Likewise.
* sysdeps/ieee754/ldbl-opt/w_acos_compat.c: Remove.
* sysdeps/ieee754/ldbl-opt/w_acosh_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_asin_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_atan2_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_atanh_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_cosh_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_exp_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_fmod_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_hypot_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_j0_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_j1_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_jn_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log10_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log2_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_pow_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_sinh_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_sqrt_compat.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_tgamma_compat.c: Likewise.
The math/ directory has various stub implementations of functions
(generally long double functions, plus sqrtf128) that set errno to
ENOSYS and print a message.
These are a relic of when the long double libm implementation in glibc
was originally incomplete. They are only present for a limited set of
libm functions, not all those that would need implementing for any
hypothetical new long double format, and only for long double (plus
sqrtf128), not for other floating-point types. I removed the
corresponding ENOSYS tests in the testsuite in
<https://sourceware.org/ml/libc-alpha/2013-05/msg00599.html>.
I think these stubs are an inherently different case from stubs for
functionality needing OS-specific implementations, since
floating-point formats are generally standardized between modern
processors (a new long double format does not seem likely - I'd expect
new ports all to have long double = binary128 or long double =
binary64 - though _Float16 functions *f16 are entirely possible in
future) and libm functions are generally only expected to fail for
domain / range / pole errors, not for other unknown system-specific
conditions the way the functions needing OS-specific implementations
may fail.
This patch removes these stub implementations. The effect (which, as
noted above, was actually mostly already the case, given the
incompleteness of the set of stubs, and was certainly the case if you
wanted your libm port to *work* rather than just build) is that any
new long double format needs to provide a full set of functions for
the build to succeed; any port using ldbl-128 needs to provide sqrtl
(possibly using the soft-fp version from another port); any port using
ldbl-96 needs to provide all those functions that all of
x86_64/i386/ia64/m68k provide rather than getting from the ldbl-96
directory; any port with _Float128 as a type with a distinct format
needs to provide sqrtf128.
Tested for x86_64. Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by the patch.
* math/e_acoshl.c: Remove.
* math/e_acosl.c: Likewise.
* math/e_asinl.c: Likewise.
* math/e_atan2l.c: Likewise.
* math/e_atanhl.c: Likewise.
* math/e_coshl.c: Likewise.
* math/e_expl.c: Likewise.
* math/e_fmodl.c: Likewise.
* math/e_gammal_r.c: Likewise.
* math/e_hypotl.c: Likewise.
* math/e_j0l.c: Likewise.
* math/e_j1l.c: Likewise.
* math/e_jnl.c: Likewise.
* math/e_lgammal_r.c: Likewise.
* math/e_log10l.c: Likewise.
* math/e_log2l.c: Likewise.
* math/e_logl.c: Likewise.
* math/e_powl.c: Likewise.
* math/e_rem_pio2l.c: Likewise.
* math/e_sinhl.c: Likewise.
* math/e_sqrtf128.c: Likewise.
* math/e_sqrtl.c: Likewise.
* math/k_cosl.c: Likewise.
* math/k_sinl.c: Likewise.
* math/k_tanl.c: Likewise.
* math/s_asinhl.c: Likewise.
* math/s_atanl.c: Likewise.
* math/s_cbrtl.c: Likewise.
* math/s_erfl.c: Likewise.
* math/s_expm1l.c: Likewise.
* math/s_log1pl.c: Likewise.
* math/s_tanhl.c: Likewise.
Some math functions have to be distributed in libc because they're
required by printf.
libc and libm require their own builds of these functions, e.g. libc
functions have to call __stack_chk_fail_local in order to bypass the
PLT, while libm functions have to call __stack_chk_fail.
While math/Makefile treat the generic cases, i.e. s_isinff, the
multiarch Makefile has to treat its own files, i.e. s_isinff-ppc64.
[BZ #21745]
* sysdeps/powerpc/powerpc64/fpu/multiarch/Makefile:
[$(subdir) = math] (sysdep_calls): New variable. Has the
previous contents of sysdep_routines, but re-sorted..
[$(subdir) = math] (sysdep_routines): Re-use the contents from
sysdep_calls.
[$(subdir) = math] (libm-sysdep_routines): Remove the functions
defined in sysdep_calls and replace by the respective m_* names.
* sysdeps/powerpc/powerpc64/fpu/multiarch/s_isnan-ppc64.S:
(compat_symbol): Undefine to avoid duplicated compat symbols in
libc.
This patch converts libm function implementations in math/ from using
weak_alias to using libm_alias_float to define public function names,
in cases where it would be appropriate to define _Float32 aliases for
those functions as well. expf and exp2f are omitted from this patch,
given the in-progress patches that would change their symbol
versioning arrangements (at a later stage it will be necessary to add
macros that can be used for functions with such symbol versioning
arrangements - which will apply to lgammaf as well - but for the
initial patches in this area I'm just dealing with easy cases, and any
symbol versioning changes to these functions while the work is in
progress can effectively just undo the libm_alias_* changes as regards
those functions).
Tested for x86_64. Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by the patch.
* math/s_fmaf.c: Include <libm-alias-float.h>.
(fmaf): Define using libm_alias_float.
* math/w_acosf_compat.c: Include <libm-alias-float.h>.
(acosf): Define using libm_alias_float.
* math/w_acoshf_compat.c: Include <libm-alias-float.h>.
(acoshf): Define using libm_alias_float.
* math/w_asinf_compat.c: Include <libm-alias-float.h>.
(asinf): Define using libm_alias_float.
* math/w_atan2f_compat.c: Include <libm-alias-float.h>.
(atan2f): Define using libm_alias_float.
* math/w_atanhf_compat.c: Include <libm-alias-float.h>.
(atanhf): Define using libm_alias_float.
* math/w_coshf_compat.c: Include <libm-alias-float.h>.
(coshf): Define using libm_alias_float.
* math/w_exp10f_compat.c: Include <libm-alias-float.h>.
(exp10f): Define using libm_alias_float.
* math/w_fmodf_compat.c: Include <libm-alias-float.h>.
(fmodf): Define using libm_alias_float.
* math/w_hypotf_compat.c: Include <libm-alias-float.h>.
(hypotf): Define using libm_alias_float.
* math/w_j0f_compat.c: Include <libm-alias-float.h>.
(j0f): Define using libm_alias_float.
(y0f): Likewise.
* math/w_j1f_compat.c: Include <libm-alias-float.h>.
(j1f): Define using libm_alias_float.
(y1f): Likewise.
* math/w_jnf_compat.c: Include <libm-alias-float.h>.
(jnf): Define using libm_alias_float.
(ynf): Likewise.
* math/w_log10f_compat.c: Include <libm-alias-float.h>.
(log10f): Define using libm_alias_float.
* math/w_log2f_compat.c: Include <libm-alias-float.h>.
(log2f): Define using libm_alias_float.
* math/w_logf_compat.c: Include <libm-alias-float.h>.
(logf): Define using libm_alias_float.
* math/w_powf_compat.c: Include <libm-alias-float.h>.
(powf): Define using libm_alias_float.
* math/w_remainderf_compat.c: Include <libm-alias-float.h>.
(remainderf): Define using libm_alias_float.
* math/w_sinhf_compat.c: Include <libm-alias-float.h>.
(sinhf): Define using libm_alias_float.
* math/w_sqrtf_compat.c: Include <libm-alias-float.h>.
(sqrtf): Define using libm_alias_float.
* math/w_tgammaf_compat.c: Include <libm-alias-float.h>.
(tgammaf): Define using libm_alias_float.
Many libm functions define the function as __<func> and then define
<func> as a weak alias. This is not at all limited to cases where
there is an internal call that has namespace reasons to need to call
__<func> instead of <func>.
The common macros for creating libm function aliases work on the basis
of public function names all being aliases; that is, they define
aliases for functions using the above pattern. Thus, where a function
just defines the public name <func> directly, changing that to be a
weak alias enables a subsequent conversion to the common macros to
retain the exact existing symbols (and so be testable by comparison of
stripped binaries).
This patch converts many existing functions to use the weak alias
pattern, as preparation for subsequent conversions to common macros.
I do expect that _FloatN/_FloatNx function aliases will end up needing
new variants of the common macros that do *not* create the original
float / double / long double name of a function - for cases where that
name is created specially to give it a particular symbol version, for
example - but for functions that can use the most common macros to
create all the public names as aliases, it makes sense for them to do
so.
Regarding the Bessel function wrappers in this patch: only float and
double wrappers are changed because the long double wrappers already
used the weak alias pattern.
Tested for x86_64, and with build-many-glibcs.py.
* include/math.h (roundeven): Change hidden_proto call to
__roundeven.
* math/w_j0_compat.c (j0): Rename to __j0 and define as weak
alias.
[NO_LONG_DOUBLE] (__j0l): New strong alias.
(y0): Rename to __y0 and define as weak alias.
[NO_LONG_DOUBLE] (__y0l): New strong alias.
* math/w_j0f_compat.c (j0f): Rename to __j0f and define as weak
alias.
(y0f): Rename to __y0f and define as weak alias.
* math/w_j1_compat.c (j1): Rename to __j1 and define as weak
alias.
[NO_LONG_DOUBLE] (__j1l): New strong alias.
(y1): Rename to __y1 and define as weak alias.
[NO_LONG_DOUBLE] (__y1l): New strong alias.
* math/w_j1f_compat.c (j1f): Rename to __j1f and define as weak
alias.
(y1f): Rename to __y1f and define as weak alias.
* math/w_jn_compat.c (jn): Rename to __jn and define as weak
alias.
[NO_LONG_DOUBLE] (__jnl): New strong alias.
(yn): Rename to __yn and define as weak alias.
[NO_LONG_DOUBLE] (__ynl): New strong alias.
* math/w_jnf_compat.c (jnf): Rename to __jnf and define as weak
alias.
(ynf): Rename to __ynf and define as weak alias.
* sysdeps/ieee754/dbl-64/s_fromfp.c (FUNC): Define to __fromfp.
(fromfp): Define as weak alias.
[NO_LONG_DOUBLE] (__fromfpl): New strong alias.
* sysdeps/ieee754/dbl-64/s_fromfpx.c (FUNC): Define to __fromfpx.
(fromfpx): Define as weak alias.
[NO_LONG_DOUBLE] (__fromfpxl): New strong alias.
* sysdeps/ieee754/dbl-64/s_getpayload.c (getpayload): Rename to
__getpayload and define as weak alias.
[NO_LONG_DOUBLE] (__getpayloadl): New strong alias.
* sysdeps/ieee754/dbl-64/s_roundeven.c (roundeven): Rename to
__roundeven and define as weak alias.
[NO_LONG_DOUBLE] (__roundevenl): New strong alias.
* sysdeps/ieee754/dbl-64/s_setpayload.c (FUNC): Define to
__setpayload.
(setpayload): Define as weak alias.
[NO_LONG_DOUBLE] (__setpayloadl): New strong alias.
* sysdeps/ieee754/dbl-64/s_setpayloadsig.c (FUNC): Define to
__setpayloadsig.
(setpayloadsig): Define as weak alias.
[NO_LONG_DOUBLE] (__setpayloadsigl): New strong alias.
* sysdeps/ieee754/dbl-64/s_totalorder.c (totalorder): Rename to
__totalorder and define as weak alias.
[NO_LONG_DOUBLE] (__totalorderl): New strong alias.
* sysdeps/ieee754/dbl-64/s_totalordermag.c (totalordermag): Rename
to __totalordermag and define as weak alias.
[NO_LONG_DOUBLE] (__totalordermagl): New strong alias.
* sysdeps/ieee754/dbl-64/s_ufromfp.c (FUNC): Define to __ufromfp.
(ufromfp): Define as weak alias.
[NO_LONG_DOUBLE] (__ufromfpl): New strong alias.
* sysdeps/ieee754/dbl-64/s_ufromfpx.c (FUNC): Define to
__ufromfpx.
(ufromfpx): Define as weak alias.
[NO_LONG_DOUBLE] (__ufromfpxl): New strong alias.
* sysdeps/ieee754/dbl-64/wordsize-64/s_getpayload.c (getpayload):
Rename to __getpayload and define as weak alias.
[NO_LONG_DOUBLE] (__getpayloadl): New strong alias.
* sysdeps/ieee754/dbl-64/wordsize-64/s_roundeven.c (roundeven):
Rename to __roundeven and define as weak alias.
[NO_LONG_DOUBLE] (__roundevenl): New strong alias.
* sysdeps/ieee754/dbl-64/wordsize-64/s_totalorder.c (totalorder):
Rename to __totalorder and define as weak alias.
[NO_LONG_DOUBLE] (__totalorderl): New strong alias.
* sysdeps/ieee754/dbl-64/wordsize-64/s_totalordermag.c
(totalordermag): Rename to __totalordermag and define as weak
alias.
[NO_LONG_DOUBLE] (__totalordermagl): New strong alias.
* sysdeps/ieee754/float128/float128_private.h (__getpayloadl): New
macro.
(__roundevenl): Likewise.
(__totalorderl): Likewise.
(__totalordermagl): Likewise
* sysdeps/ieee754/float128/s_fromfpf128.c (FUNC): Define to
__fromfpf128.
(fromfpf128): Define as weak alias.
* sysdeps/ieee754/float128/s_fromfpxf128.c (FUNC): Define to
__fromfpxf128.
(fromfpxf128): Define as weak alias.
* sysdeps/ieee754/float128/s_setpayloadf128.c (FUNC): Define to
__setpayloadf128.
(setpayloadf128): Define as weak alias.
* sysdeps/ieee754/float128/s_setpayloadsigf128.c (FUNC): Define to
__setpayloadsigf128.
(setpayloadsigf128): Define as weak alias.
* sysdeps/ieee754/float128/s_ufromfpf128.c (FUNC): Define to
__ufromfpf128.
(ufromfpf128): Define as weak alias.
* sysdeps/ieee754/float128/s_ufromfpxf128.c (FUNC): Define to
__ufromfpxf128.
(ufromfpxf128): Define as weak alias.
* sysdeps/ieee754/flt-32/s_fromfpf.c (FUNC): Define to __fromfpf.
(fromfpf): Define as weak alias.
* sysdeps/ieee754/flt-32/s_fromfpxf.c (FUNC): Define to
__fromfpxf.
(fromfpxf): Define as weak alias.
* sysdeps/ieee754/flt-32/s_getpayloadf.c (getpayloadf): Rename to
__getpayloadf and define as weak alias.
* sysdeps/ieee754/flt-32/s_roundevenf.c (roundevenf): Rename to
__roundevenf and define as weak alias.
* sysdeps/ieee754/flt-32/s_setpayloadf.c (FUNC): Define to
__setpayloadf.
(setpayloadf): Define as weak alias.
* sysdeps/ieee754/flt-32/s_setpayloadsigf.c (FUNC): Define to
__setpayloadsigf.
(setpayloadsigf): Define as weak alias.
* sysdeps/ieee754/flt-32/s_totalorderf.c (totalorderf): Rename to
__totalorderf and define as weak alias.
* sysdeps/ieee754/flt-32/s_totalordermagf.c (totalordermagf):
Rename to __totalordermagf and define as weak alias.
* sysdeps/ieee754/flt-32/s_ufromfpf.c (FUNC): Define to
__ufromfpf.
(ufromfpf): Define as weak alias.
* sysdeps/ieee754/flt-32/s_ufromfpxf.c (FUNC): Define to
__ufromfpxf.
(ufromfpxf): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_fromfpl.c (FUNC): Define to
__fromfpl.
(fromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_fromfpxl.c (FUNC): Define to
__fromfpxl.
(fromfpxl): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_getpayloadl.c (getpayloadl): Rename
to __getpayloadl and define as weak alias.
* sysdeps/ieee754/ldbl-128/s_roundevenl.c (roundevenl): Rename to
__roundevenl and define as weak alias.
* sysdeps/ieee754/ldbl-128/s_setpayloadl.c (FUNC): Define to
__setpayloadl.
(setpayloadl): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_setpayloadsigl.c (FUNC): Define to
__setpayloadsigl.
(setpayloadsigl): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_totalorderl.c (totalorderl): Rename
to __totalorderl and define as weak alias.
* sysdeps/ieee754/ldbl-128/s_totalordermagl.c (totalordermagl):
Rename to __totalordermagl and define as weak alias.
* sysdeps/ieee754/ldbl-128/s_ufromfpl.c (FUNC): Define to
__ufromfpl.
(ufromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-128/s_ufromfpxl.c (FUNC): Define to
__ufromfpxl.
(ufromfpxl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_fromfpl.c (FUNC): Define to
__fromfpl.
(fromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_fromfpxl.c (FUNC): Define to
__fromfpxl.
(fromfpxl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_getpayloadl.c (getpayloadl):
Rename to __getpayloadl and define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_roundevenl.c (roundevenl): Rename
to __roundevenl and define as weak alias. Call __roundeven
instead of roundeven.
* sysdeps/ieee754/ldbl-128ibm/s_setpayloadl.c (FUNC): Define to
__setpayloadl.
(setpayloadl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_setpayloadsigl.c (FUNC): Define to
__setpayloadsigl.
(setpayloadsigl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_totalorderl.c (totalorderl):
Rename to __totalorderl and define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_totalordermagl.c (totalordermagl):
Rename to __totalordermagl and define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_ufromfpl.c (FUNC): Define to
__ufromfpl.
(ufromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-128ibm/s_ufromfpxl.c (FUNC): Define to
__ufromfpxl.
(ufromfpxl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_fromfpl.c (FUNC): Define to
__fromfpl.
(fromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_fromfpxl.c (FUNC): Define to
__fromfpxl.
(fromfpxl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_getpayloadl.c (getpayloadl): Rename to
__getpayloadl and define as weak alias.
* sysdeps/ieee754/ldbl-96/s_roundevenl.c (roundevenl): Rename to
__roundevenl and define as weak alias.
* sysdeps/ieee754/ldbl-96/s_setpayloadl.c (FUNC): Define to
__setpayloadl.
(setpayloadl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_setpayloadsigl.c (FUNC): Define to
__setpayloadsigl.
(setpayloadsigl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_totalorderl.c (totalorderl): Rename to
__totalorderl and define as weak alias.
* sysdeps/ieee754/ldbl-96/s_totalordermagl.c (totalordermagl):
Rename to __totalordermagl and define as weak alias.
* sysdeps/ieee754/ldbl-96/s_ufromfpl.c (FUNC): Define to
__ufromfpl.
(ufromfpl): Define as weak alias.
* sysdeps/ieee754/ldbl-96/s_ufromfpxl.c (FUNC): Define to
__ufromfpxl.
(ufromfpxl): Define as weak alias.
Keeping the same buffers along with copying the same size of data into
the same location means that the first routine is typically the
slowest since it has to bear the cost of fetching data into to cache.
Reallocating buffers stabilizes numbers by a bit.
* benchtests/bench-string.h (realloc_bufs): New function.
(test_init): Call it.
* benchtests/bench-memset-large.c (do_test): Likewise.
* benchtests/bench-memset.c (do_test): Likewise.
Make the memset benchmarks (bench-memset and bench-memset-large) print
their output in JSON so that they can be evaluated using the
compare_strings.py script.
* benchtests/bench-memset-large.c: Print output in JSON
format.
* benchtests/bench-memset.c: Likewise.
This code page is identical to code page 850 except that X'D5'
has been changed from LI61 (dotless i) to SC20 (euro symbol).
The code points from /x01 to /x1f in the /localedata/charmaps/IBM858
file have the same mapping as those in localedata/charmaps/ANSI_X3.4-1968.
That means they disagree with with
ftp://ftp.software.ibm.com/software/globalization/gcoc/attachments/CP00858.txt
in that range.
For example, localedata/charmaps/IBM858 and localedata/charmaps/ANSI_X3.4-1968 have:
“<U0001> /x01 START OF HEADING (SOH)”
whereas CP00858.txt has:
“01 SS000000 Smiling Face”
That means that CP00858.txt is not really ASCII-compatible and to make
it ASCII-compatible we deviate fro CP00858.txt in the code points from /x01
to /x1f.
[BZ #21084]
* benchtests/strcoll-inputs/filelist#en_US.UTF-8: Add IBM858 and ibm858.c.
* iconvdata/Makefile: Add IBM858.
* iconvdata/gconv-modules: Add IBM858.
* iconvdata/ibm858.c: New file.
* iconvdata/tst-tables.sh: Add IBM858
* localedata/charmaps/IBM858: New file.
Continuing the process of setting up common macros for libm function
aliases, with a view to using them to define _FloatN / _FloatNx
aliases in future, this patch adds a libm_alias_float128 macro and
uses it in the type-generic templates. (_Float128 functions will end
up with _Float64x aliases on powerpc64le, but not on x86_64/x86/ia64
because _Float64x has long double format there, and the macro will
provide a single place for the conditionals for that choice, as well
as for once ldbl-128 functions always build *f128 and need
conditionals for whether to have *l aliases.)
Tested for x86_64. Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by the patch.
* sysdeps/generic/libm-alias-float128.h: New file.
* sysdeps/generic/math-type-macros-float128.h: Include
<libm-alias-float128.h>.
[!declare_mgen_alias] (declare_mgen_alias): Define macro.
Continuing the process of setting up common macros for libm function
aliases, with a view to using them to define _FloatN / _FloatNx
aliases in future, this patch adds a libm_alias_ldouble macro and uses
it in the type-generic templates.
Since math-type-macros-ldouble.h already did the appropriate thing for
each symbol (weak_alias or long_double_symbol), this is just a
straightforward rearrangement of code, to make the required logic
available in a place that can also be used outside of the type-generic
templates in future (in particular, to eliminate various wrappers for
functions in ldbl-opt and ldbl-64-128).
Tested for x86_64. Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by the patch.
* sysdeps/generic/libm-alias-ldouble.h: New file.
* sysdeps/ieee754/ldbl-opt/libm-alias-ldouble.h: Likewise.
* sysdeps/ieee754/ldbl-opt/math-type-macros-ldouble.h: Remove.
* sysdeps/generic/math-type-macros-ldouble.h: Include
<libm-alias-ldouble.h>.
[!declare_mgen_alias] (declare_mgen_alias): Define to use
libm_alias_ldouble.
This patch cleans up how compat symbols / long double versioning are
handled for log1p, ldexp, scalbn and scalbln functions.
The general principle is to do as much as possible through the
type-generic templates. Previously, when errno-setting wrappers were
added the compat long double symbols were left pointing directly to
the underlying implementations; they are moved to point to the
errno-setting wrappers. For the functions also present in libc,
compat symbol handling for the libc copies needs to go in ldbl-opt
wrappers, but the type-generic templates can handle it for the libm
copies. There is no need for w_scalbln_template.c to disable the
creation of an unused internal alias (such code made sense in the
context of patches trying to avoid any changes to generated code for
ease of comparison, but can be removed in a change that specifically
does intend to change details of where symbols point).
Tested for x86_64, and with build-many-glibcs.py.
* math/w_scalbln_template.c (strong_alias): Do not undefine and
redefine.
* sysdeps/ieee754/ldbl-opt/s_ldexp.c (declare_mgen_alias): Remove
macro.
(ldexpl): Only define as compat symbol for libc, not libm.
(scalbnl): Define as compat symbol for libc here.
* sysdeps/ieee754/ldbl-opt/s_ldexpl.c (declare_mgen_alias): Only
define for [IS_IN (libc)].
(__ldexpl_2): Remove alias.
(ldexpl): Only define with long_double_symbol if [IS_IN (libc)].
(scalbnl): Likewise. Use __wrap_scalbnl not __ldexpl_2 as base
name in long_double_symbol call.
* sysdeps/ieee754/ldbl-opt/s_log1p.c: Remove file.
* sysdeps/ieee754/ldbl-opt/s_scalbln.c: Likewise.
* sysdeps/ieee754/ldbl-opt/s_scalbn.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_log1p.c: Likewise.
* sysdeps/ieee754/ldbl-opt/w_scalbln.c (declare_mgen_alias):
Remove macro.
[IS_IN (libc) && LONG_DOUBLE_COMPAT (libc, GLIBC_2_1)] (scalblnl):
Define as compat symbol.
This patch fixes the compat glob implementation consolidation from
commit 116f1c64d with the following changes:
- Add a compat implementation on s390 to avoid the architecture
to build the symbols on default linux oldglob.c by setting
GLOB_NO_OLD_VERSION.
- Remove the duplicate rule to build oldglob on alpha.
Checked on s390-linux-gnu and alpha-linux-gnu using build-many-glibc.py.
* sysdeps/unix/sysv/linux/s390/s390-32/oldglob.c: New file.
* sysdeps/unix/sysv/linux/alpha/Makefile
[$(subdir) = csu] (sysdep_routines): Remove rule.
Continuing the process of setting up common macros for libm function
aliases, with a view to using them to define _FloatN / _FloatNx
aliases in future, this patch adds a libm_alias_double macro and uses
it in the type-generic templates.
This macro handles defining aliases for double, and for long double in
the NO_LONG_DOUBLE case. It also handles defining compat symbols for
long double = double for architectures that changed their long double
format. By so doing, it eliminates the need for the
M_LIBM_NEED_COMPAT and declare_mgen_libm_compat macros; the single
declare_mgen_alias call in each template now suffices to define all
required compat symbols. When used for more double functions (not
based on type-generic templates), I expect it will eliminate the need
for most ldbl-opt wrappers for such functions.
A few special cases are needed. __clog10l is a public symbol (for
historical reasons) so needs to be given appropriate compat versions
for architectures that changed their long double format, but is not
defined as an alias using the normal macros since __clog10* are *not*
public symbols for _FloatN / _FloatNx types. For scalbn, scalbln and
log1p, the changes adding errno setting support for those functions
left compat symbols pointing directly to the non-errno-setting
implementations. There is no requirement for the compat symbols not
to set errno; that just made for the simplest patches at that time.
Now, with these common macros, it's natural to redirect the compat
symbols to the errno-setting wrappers, which I intend to do in a
separate patch.
Tested for x86_64, and with build-many-glibcs.py. For ldbl-opt
platforms the stripped libm.so binaries are changed (disassembly
unchanged) because the details of how the clog10l compat symbol is
created mean it ceases to be weak as it was before; for other
platforms, stripped libm.so binaries are unchanged.
2017-09-13 Joseph Myers <joseph@codesourcery.com>
* sysdeps/generic/libm-alias-double.h: New file.
* sysdeps/ieee754/ldbl-opt/libm-alias-double.h: Likewise.
* sysdeps/generic/math-type-macros-double.h: Include
<libm-alias-double.h>.
[declare_mgen_alias] (declare_mgen_alias): Define to use
libm_alias_double.
* sysdeps/generic/math-type-macros.h [!M_LIBM_NEED_COMPAT]
(M_LIBM_NEED_COMPAT): Remove macro.
[!M_LIBM_NEED_COMPAT] (declare_mgen_libm_compat): Likewise.
* sysdeps/ieee754/ldbl-opt/math-type-macros-double.h: Remove.
* math/cabs_template.c [M_LIBM_NEED_COMPAT]: Remove conditional
code.
* math/carg_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/cimag_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/conj_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/creal_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_cacos_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_cacosh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_casin_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_casinh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_catan_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_catanh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_ccos_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_ccosh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_cexp_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_clog10_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_clog_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_cpow_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_cproj_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_csin_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_csinh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_csqrt_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_ctan_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_ctanh_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_fdim_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_fmax_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_fmin_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/s_nan_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* math/w_ilogb_template.c [M_LIBM_NEED_COMPAT]: Likewise.
* sysdeps/ieee754/ldbl-opt/s_clog10.c: New file.
* sysdeps/ieee754/ldbl-opt/s_ldexp.c (M_LIBM_NEED_COMPAT): Remove
macro.
(declare_mgen_alias): New macro.
* sysdeps/ieee754/ldbl-opt/w_log1p.c: New file.
* sysdeps/ieee754/ldbl-opt/w_scalbln.c: Likewise.
* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim-vis3.c
(M_LIBM_NEED_COMPAT): Remove macro.
* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim.c
[HAVE_AS_VIS3_SUPPORT]: Include <math_ldbl_opt.h> and
<first-versions.h>.
[HAVE_AS_VIS3_SUPPORT && LONG_DOUBLE_COMPAT (libm,
FIRST_VERSION_libm_fdiml)]: Define fdiml as compat symbol.
The libm template machinery includes a macro declare_mgen_alias_2, to
define two function aliases rather than one. This macro is only used
in one place, to define ldexp and scalbn, and only has one nondefault
definition, for double in the case where long double has the same
format. That definition is because declare_mgen_alias for double, in
that case, defines <internal-func>l as an alias of <internal-func>, so
cannot be called twice for aliases of the same function.
Now, I suspect the <internal-func>l aliases are generally not needed
(with maybe a few exceptions such as __clog10l, which is an exported
function). But even in the presence of them, there is no need for a
special declare_mgen_alias_2 macro for this case. This patch
eliminates the need for such a macro by defining __wrap_scalbn<suffix>
as an alias of __ldexp<suffix>, and then using that when defining the
scalbn public aliases. This is similar to how such internal aliases
are created for functions with multiple symbol versions, for example.
Tested for x86_64, and with build-many-glibcs.py. (There *are* some
cases where installed stripped shared libraries change - not in the
generated code but because such changes to static symbols on input to
ld, even nonexported symbols that don't affect the code or dynamic
symbols, can affect the particular representation in the output of
string tables, hash tables etc.)
* sysdeps/generic/math-type-macros.h [!declare_mgen_alias_2]
(declare_mgen_alias_2): Remove.
* sysdeps/generic/math-type-macros-double.h
[NO_LONG_DOUBLE && !declare_mgen_alias_2] (declare_mgen_alias_2):
Likewise.
* math/s_ldexp_template.c (M_SUF (__wrap_scalbn)): Define strong
alias.
(ldexp): Define with declare_mgen_alias.
(scalbn): Likewise.
AVX512 functions in mathvec are used on machines with AVX512. An AVX2
wrapper is also provided and it can be used when the AVX512 version
isn't profitable. MathVec_Prefer_No_AVX512 is addded to cpu-features.
If glibc.tune.hwcaps=MathVec_Prefer_No_AVX512 is set in GLIBC_TUNABLES
environment variable, the AVX2 wrapper will be used.
Tested on x86-64 machines with and without AVX512. Also verified
glibc.tune.hwcaps=MathVec_Prefer_No_AVX512 on AVX512 machine.
[BZ #21967]
* sysdeps/x86/cpu-features.h (bit_arch_MathVec_Prefer_No_AVX512):
New.
(index_arch_MathVec_Prefer_No_AVX512): Likewise.
* sysdeps/x86/cpu-tunables.c (TUNABLE_CALLBACK (set_hwcaps)):
Handle MathVec_Prefer_No_AVX512.
* sysdeps/x86_64/fpu/multiarch/ifunc-mathvec-avx512.h
(IFUNC_SELECTOR): Return AVX2 version if MathVec_Prefer_No_AVX512
is set.
Fully supporting TS 18661-3 _FloatN / _FloatNx types in the cases
where they have the same format as other supported types (in line with
the principles described at
<https://sourceware.org/ml/libc-alpha/2017-01/msg00333.html>) means
adding a lot of function aliases to libm (and a few to libc). float
functions will have *f32 aliases, double functions will have *f32x and
*f64 aliases, long double functions may have *f64x, *f128 or both
aliases depending on the configuration, float128 functions have have
*f64x aliases depending on the configuration.
At present, most individual libm functions have their own weak_alias
calls to define the public names for those functions. For TS 18661-3
support, it is desirable that functions not all need to duplicate the
logic for which alias names to define.
Thus, common macros for defining the public aliases to a libm function
make sense. In the double and long double cases, such macros will
also help simplify existing code (with LONG_DOUBLE_COMPAT
etc. conditionals), by eliminating existing conditionals and ldbl-opt
/ ldbl-64-128 wrappers (using the generated ldbl-compat-choose.h to
allow a single macro definition to expand appropriately for each
symbol depending on LONG_DOUBLE_COMPAT for that symbol).
This patch starts the process of adding such macros with a
straightforward case: a libm_alias_float macro, initially only used in
the case of type-generic templates, to define aliases for float
functions (currently just the *f public names, in future also *f32).
Future patches are intended to add such macros for other types and to
extend the cases in which they are used, with a view to as many places
as possible using them before support for _FloatN / _FloatNx aliases
is enabled. (I think it's inevitable that some places doing
architecture-specific things with aliases and symbol versioning may
end up needing to replicate logic for the new aliases, but hopefully
the number of such places can be kept to a minimum.)
The libm_alias_float macro takes unsuffixed names for both the
internal and public function names. The need for unsuffixed public
names is obvious, since such macros will end up defining multiple
public names with different suffixes. Unsuffixed internal names are
because I expect the ldbl-128 functions to end up in a form that
always defines *f128 names and sometimes also defines *l names - with
the main internal names being e.g. __ieee754_<func>f128 (so many
macros in float128_private.h can go away). But __ieee754_<func>l
aliases will still be needed for e.g. use from math/ complex
functions, meaning the alias macro needs to see just __ieee754_<func>
as internal name so it can create an alias based on that name. Since
libm_alias_float128 will thus need the unsuffixed internal name, it
seems to make sense for all such macros to receive the unsuffixed
name.
Tested for x86_64. Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by the patch.
* sysdeps/generic/libm-alias-float.h: New file.
* sysdeps/generic/math-type-macros-float.h: Include
<libm-alias-float.h>.
[!declare_mgen_alias] (declare_mgen_alias): Define macro.
Before glibc 2.26, ld.so set dl_platform to "x86_64" and searched the
"x86_64" subdirectory when loading a shared library. ld.so in glibc
2.26 was changed to set dl_platform to "haswell" or "xeon_phi", based
on supported ISAs. This led to shared library loading failure for
shared libraries placed under the "x86_64" subdirectory.
This patch adds "x86_64" to x86-64 dl_hwcap so that ld.so will always
search the "x86_64" subdirectory when loading a shared library.
NB: We can't set x86-64 dl_platform to "x86-64" since ld.so will skip
the "haswell" and "xeon_phi" subdirectories on "haswell" and "xeon_phi"
machines.
Tested on i686 and x86-64.
[BZ #22093]
* sysdeps/x86/cpu-features.c (init_cpu_features): Initialize
GLRO(dl_hwcap) to HWCAP_X86_64 for x86-64.
* sysdeps/x86/dl-hwcap.h (HWCAP_COUNT): Updated.
(HWCAP_IMPORTANT): Likewise.
(HWCAP_X86_64): New enum.
(HWCAP_X86_AVX512_1): Updated.
* sysdeps/x86/dl-procinfo.c (_dl_x86_hwcap_flags): Add "x86_64".
* sysdeps/x86_64/Makefile (tests): Add tst-x86_64-1.
(modules-names): Add x86_64/tst-x86_64mod-1.
(LDFLAGS-tst-x86_64mod-1.so): New.
($(objpfx)tst-x86_64-1): Likewise.
($(objpfx)x86_64/tst-x86_64mod-1.os): Likewise.
(tst-x86_64-1-clean): Likewise.
* sysdeps/x86_64/tst-x86_64-1.c: New file.
* sysdeps/x86_64/tst-x86_64mod-1.c: Likewise.
2.3 is not representable with double, and thus leads to rounding issues if
the clock is not very precise and the measured delay is then exactly 2.3.
* sunrpc/tst-udp-timeout.c (test_udp_server): Increase timeout to 2.5
seconds.
“Bengali” still remained in some comments in the bn_BD locale file,
in iso-639.def and in a test input file. Change it there as well.
“Bangla” is now used as the English name for this language in CLDR.
[BZ #14925]
* libio/tst-widetext.input: Change “Bengali” to “Bangla”.
* locale/iso-639.def: Change “Bengali” to “Bangla”.
* localedata/locales/bn_BD: “Bengali” was still used in some
comments. Change it to “Bangla”.
* manual/tunables.texi (glibc.tune.cpu): Add thunderx2t99 and
thunderx2t99p1 to list of cpu names.
* sysdeps/unix/sysv/linux/aarch64/cpu-features.c (cpu_list):
Add thunderx2t99 and thunderx2t99p1 entries to cpu_list.
While reviewing Linux 4.13 for glibc header changes needed, I noticed
that bits/fcntl-linux.h was missing F_ADD_SEALS etc. from Linux 3.17.
I didn't find any discussion indicating this omission is deliberate.
Now, these interfaces can only be used with file descriptors created
with memfd_create, and we don't have a memfd_create wrapper in glibc
(a patch was submitted in October 2014, albeit without documentation /
tests, and discussions continued over the next few months, but without
consensus on whether to add the interface - and we still lack any
general consensus on syscall wrappers), but I don't think that's a
reason to exclude the constants from bits/fcntl-linux.h (especially as
the header does not look compatible with simultaneously including
linux/fcntl.h).
(Some of those 2014/2015 discussions raised concerns about difficulty
using the memfd_create / sealing interface, but those seem to me more
like a question of whether it should be part of the OS-independent GNU
API - in my view, even fairly specialized syscalls ought to have
wrappers added to glibc if not obsolescent, but there may be cases
where we only want to include them in the Linux-specific API and
anything in the OS-independent GNU API should be different - rather
than being relevant to whether constants for use with fcntl should
appear in headers.)
* sysdeps/unix/sysv/linux/bits/fcntl-linux.h [__USE_GNU]
(F_ADD_SEALS): New macro.
[__USE_GNU] (F_GET_SEALS): Likewise.
[__USE_GNU] (F_SEAL_SEAL): Likewise.
[__USE_GNU] (F_SEAL_SHRINK): Likewise.
[__USE_GNU] (F_SEAL_GROW): Likewise.
[__USE_GNU] (F_SEAL_WRITE): Likewise.
This patch replaces the internal integer constant from
__glob_pattern_type return with a proper enum.
Checked on x86_64-linux-gnu and on a build using build-many-glibcs.py
for all major architectures.
* posix/glob_internal.h (glob_pattern_type_t): New enumeration.
(__glob_pattern_type): Use __glob_pat_types.
* posix/glob_pattern_p.c (__glob_pattern_p): Likewise.
* posix/glob.c (glob): Likewise.
(glob_in_dir): Likewise.
This patch consolidates the glob implementation. The main changes are:
* On Linux all implementation now uses the default one at
sysdeps/unix/sysv/linux/glob{free}{64}.c with the exception
of alpha (which requires specific versioning) and s390-32 (which
different than other 32 bits ports it does not add a compat one
symbol for 2.1 version).
* The default implementation uses XSTAT_IS_XSTAT64 to define whether
both glob{free} and glob{free}64 should be different implementations.
For archictures that define XSTAT_IS_XSTAT64, glob{free} is an alias
to glob{free}64.
* Move i386 olddirent.h header to Linux default directory, since it is
the only header with this name and it is shared among different
architectures (and used on compat glob symbol as well).
Checked on x86_64-linux-gnu and on a build using build-many-glibcs.py
for all major architectures.
* sysdeps/unix/sysv/linux/arm/glob64.c: Remove file.
* sysdeps/unix/sysv/linux/i386/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/m68k/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n64/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/n64/globfree64.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/sparc/sparc32/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/wordsize-64/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/wordsize-64/globfree64.c: Likewise.
* sysdeps/unix/sysv/linux/x86_64/x32/glob.c: Likewise.
* sysdeps/unix/sysv/linux/x86_64/x32/globfree.c: Likewise.
* sysdeps/wordsize-64/glob.c: Likewise.
* sysdeps/wordsize-64/glob64.c: Likewise.
* sysdeps/wordsize-64/globfree64.c: Likewise.
* sysdeps/unix/sysv/linux/glob.c: New file.
* sysdeps/unix/sysv/linux/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/globfree.c: Likewise.
* sysdeps/unix/sysv/linux/globfree64.c: Likewise.
* sysdeps/unix/sysv/linux/s390/s390-32/glob64.c: Likewise.
* sysdeps/unix/sysv/linux/oldglob.c [SHLIB_COMPAT]: Also
adds !GLOB_NO_OLD_VERSION as an extra condition.
* sysdeps/unix/sysv/linux/i386/alphasort64.c: Include olddirent.h
using relative path instead of absolute one.
* sysdeps/unix/sysv/linux/i386/getdents64.c: Likewise.
* sysdeps/unix/sysv/linux/i386/readdir64.c: Likewise.
* sysdeps/unix/sysv/linux/i386/readdir64_r.c: Likewise.
* sysdeps/unix/sysv/linux/i386/versionsort64.c: Likewise.
* sysdeps/unix/sysv/linux/i386/olddirent.h: Move to ...
* sysdeps/unix/sysv/linux//olddirent.h: ... here.
