AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-25 04:01:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

powerpc64le: ifunc select *f128 routines in multiarch mode

Browse Source 
Programatically generate simple wrappers for interesting libm *f128
objects.  Selected functions are transcendental functions or
those with trivial compiler builtins.  This can result in a 2-3x
speedup (e.g logf128 and expf128).

A second set of implementation files are generated which include
the first implementation encountered along the search path.  This
usually works, except when a wrapper is overriden and makefile
search order slightly diverges from include order.  Likewise,
wrapper object files are created for each generated file.  These
hold the ifunc selection routines which export ABI.

Next, several shared headers are intercepted to control renaming of
asm function redirects are used first, and sometimes macro renames
if the former is impractical.

Notably, if the request machine supports hardware IEEE128 (i.e POWER9
and newer) this ifunc machinery is disabled.  Likewise existing
ifunc support for float128 is consolidated into this (e.g sqrtf128
and fmaf128).

Reviewed-by: Tulio Magno Quites Machado Filho <tuliom@linux.ibm.com>
This commit is contained in:
Paul E. Murphy 2020-04-07 16:20:55 -05:00 committed by Paul E. Murphy
parent cc5d5852c6
commit 33fc34521d
16 changed files with 818 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
sysdeps/powerpc/powerpc64/le/fpu/multiarch/Makefile
View File

@ -1,10 +1,202 @@
ifeq ($(subdir),math)
libm-sysdep_routines += s_fmaf128-ppc64 s_fmaf128-power9 \
w_sqrtf128-power9 w_sqrtf128-ppc64le
CFLAGS-s_fmaf128-ppc64.c += $(type-float128-CFLAGS) $(no-gnu-attribute-CFLAGS)
CFLAGS-s_fmaf128-power9.c += $(type-float128-CFLAGS) -mcpu=power9 $(no-gnu-attribute-CFLAGS)
CFLAGS-w_sqrtf128-ppc64le.c += $(type-float128-CFLAGS) $(no-gnu-attribute-CFLAGS)
CFLAGS-w_sqrtf128-power9.c += $(type-float128-CFLAGS) -mcpu=power9 $(no-gnu-attribute-CFLAGS)
#
# Only enable ifunc _Float128 support if the baseline cpu support
# is older than power9.
ifneq (yes,$(libc-submachine-power9))
do_f128_multiarch = yes
endif
#
# This is an ugly, but contained, mechanism to provide hardware optimized
# _Float128 and ldouble == ieee128 optimized routines for P9 and beyond
# hardware. At a very high level, we rely on ASM renames, and rarely
# macro renames to build two sets of _Float128 ABI, one with _power8 (the
# baseline powerpc64le cpu) and _power9 (the first powerpc64le cpu to introduce
# hardware support for _Float128).
#
# At a high level, we compile 3 files for each object file.
# 1. The baseline soft-float128, unsuffixed objects $(object).$(sfx)
# The symbols contained in these files is suffixed by _power8.
# 2. The hard-float128, power9, suffixed objects $(object)-power9.$(sfx).
# The symbols contained in these files is suffixed by _power9.
# 3. The IFUNC wrapper object to export ABI, $(object)-ifunc.$(sfx)
# This glues the above together and implements the ABI.
#
# 2 & 3 are automatically generated by Makefile rule. Placing the exported
# ABI into a separate file allows reuse of existing aliasing macros
# with minimal hassle.
#
#
# If the float128 ABI is expanded, and a new ifunc wrappers are desired,
# the following lists how to map new symbols from the shared headers into
# their local overrides here:
#
# float128_private.h
#
# is used to rename the ldouble == ieee128 object files. This takes
# it a step further and redirects symbols to a local name. This supports
# nearly all files in sysdeps/ieee754/float128, but not all _Float128
# objects. However, this is only meant to be used internally to support
# compilation of ldbl-128 into float128.
#
# math-type-macros-float128.h
#
# renames symbols which are generated via shared templated in math/.
#
# math_private.h
#
# provides internal declarations for common macros and functions which
# are called from within libm. Note, float128_private.h duplicates
# some of these declarations as these headers are generally not included
# in the same translation unit.
#
# The above is supported by several header files as described below:
#
# float128-ifunc.h
#
# provides support for generating the IFUNC objects in part 3 above.
# This header is only included with wrapper functions.
#
# float128-ifunc-macros.h
#
# disables all first-order float128 aliasing macros used in libm,
# and libm wrappers around libc-symbols.h.
#
# float128-ifunc-redirect-macros.h
#
# provides macros which implement the appending of the suffix to
# symbols what have been selected.
#
# float128-ifunc-redirects.h
#
# provides ASM redirects for symbols which are redirected in the
# private copy of math.h used by glibc, but not declared by math_private.h
#
# float128-ifunc-redirects-mp.h
#
# provides ASM redirects which are used by math_private.h (the -mp suffix)
# and the interposer float128_private.h discussed late.
#
# Notably, this enforces a slightly different mechanism for machine specific
# overrides. Optimizations for all targets must all be reachable from the same
# file. See the history to fmaf128 or sqrtf128 to understand how this looks
# in practice.
#
ifeq ($(do_f128_multiarch),yes)
gen-libm-f128-ifunc-routines = \
e_acosf128 e_acoshf128 e_asinf128 e_atan2f128 e_atanhf128 e_coshf128 \
e_expf128 e_fmodf128 e_hypotf128 e_j0f128 e_j1f128 e_jnf128 \
e_lgammaf128_r e_logf128 e_log10f128 e_powf128 e_remainderf128 \
e_sinhf128 e_sqrtf128 e_gammaf128_r e_ilogbf128 k_tanf128 s_asinhf128 \
s_atanf128 s_cbrtf128 s_ceilf128 s_cosf128 s_erff128 s_expm1f128 \
s_fabsf128 s_floorf128 s_log1pf128 s_logbf128 \
s_rintf128 s_scalblnf128 s_sinf128 s_tanf128 \
s_tanhf128 s_truncf128 s_remquof128 e_log2f128 \
s_roundf128 s_nearbyintf128 s_sincosf128 s_fmaf128 s_lrintf128 \
s_llrintf128 s_lroundf128 s_llroundf128 e_exp10f128 \
m_modff128 m_scalbnf128 m_frexpf128 m_ldexpf128 x2y2m1f128 \
gamma_productf128 lgamma_negf128 lgamma_productf128 s_roundevenf128 \
cargf128 conjf128 cimagf128 crealf128 cabsf128 e_scalbf128 s_cacosf128 \
s_cacoshf128 s_ccosf128 s_ccoshf128 s_casinf128 s_csinf128 \
s_casinhf128 k_casinhf128 s_csinhf128 k_casinhf128 s_csinhf128 \
s_catanhf128 s_catanf128 s_ctanf128 s_ctanhf128 s_cexpf128 s_clogf128 \
s_cprojf128 s_csqrtf128 s_cpowf128 s_clog10f128 s_fdimf128 \
s_fmaxf128 s_fminf128 w_ilogbf128 w_llogbf128 \
w_log1pf128 w_scalblnf128 w_acosf128 \
w_acoshf128 w_asinf128 w_atan2f128 w_atanhf128 w_coshf128 w_exp10f128 \
w_exp2f128 w_fmodf128 w_hypotf128 w_j0f128 w_j1f128 w_jnf128 \
w_logf128 w_log10f128 w_log2f128 w_powf128 w_remainderf128 \
w_scalbf128 w_sinhf128 w_sqrtf128 w_tgammaf128 w_lgammaf128 \
w_lgammaf128_r w_expf128 e_exp2f128 \
k_sinf128 k_cosf128 k_sincosf128 e_rem_pio2f128
f128-march-routines-p9 = $(addsuffix -power9,$(gen-libm-f128-ifunc-routines))
f128-march-routines-ifunc = $(addsuffix -ifunc,$(gen-libm-f128-ifunc-routines))
f128-march-routines = $(f128-march-routines-p9) $(f128-march-routines-ifunc)
f128-march-cpus = power9
libm-routines += $(f128-march-routines)
generated += $(f128-march-routines)
CFLAGS-float128-ifunc.c += $(type-float128-CFLAGS) $(no-gnu-attribute-CFLAGS)
# Copy special CFLAGS for some functions
CFLAGS-m_modff128-power9.c += -fsignaling-nans
# Generate ifunc wrapper files and target specific wrappers around
# each routine above. Note, m_%.c files are fixed up to include
# s_%.c files. This is an artifact of the makefile rules which allow
# some files to be compiled for libc and libm.
$(objpfx)gen-float128-ifuncs.stmp: Makefile
$(make-target-directory)
for gcall in $(gen-libm-f128-ifunc-routines); do \
ifile="$${gcall}"; \
if [ $${gcall##m_} != $${gcall} ]; then \
ifile="s_$${gcall##m_}"; \
fi; \
for cpu in $(f128-march-cpus); do \
file=$(objpfx)$${gcall}-$${cpu}.c; \
{ \
echo "#include <$${ifile}.c>"; \
} > $${file}; \
done; \
name="$${gcall##?_}"; \
pfx="$${gcall%%_*}"; \
R=""; \
r=""; \
if [ $${gcall##m_} != $${gcall} ]; then \
pfx="s"; \
fi; \
if [ $${#pfx} != 1 ]; then \
pfx=""; \
else \
pfx="_$${pfx}"; \
fi; \
if [ $${name%%_r} != $${name} ]; then \
R="_R"; \
r="_r"; \
name="$${name%%_r}"; \
fi; \
name="$${name%%f128}"; \
decl="DECL_ALIAS$${pfx}_$${name}$${r}"; \
compat="GEN_COMPAT$${pfx}_$${name}$${r}"; \
declc="DECL_ALIAS$${R}$${pfx}"; \
{ \
echo "#include <float128-ifunc.h>"; \
echo "#ifndef $${decl}"; \
echo "# define $${decl}(f) $${declc} (f)"; \
echo "#endif"; \
echo "#ifndef $${compat}"; \
echo "# define $${compat}(f)"; \
echo "#endif"; \
echo "$${decl} ($${name});"; \
echo "$${compat} ($${name});"; \
} > $(objpfx)$${gcall}-ifunc.c; \
done; \
echo > $(@)
$(foreach f,$(f128-march-routines),$(objpfx)$(f).c): $(objpfx)gen-float128-ifuncs.stmp
enable-f128-ifunc-CFLAGS = -D_F128_ENABLE_IFUNC $(no-gnu-attributes-CFLAGS) $(type-float128-CFLAGS)
# Enable IFUNC on baseline (power8) implementations
include $(o-iterator)
define o-iterator-doit
$(foreach f,$(gen-libm-f128-ifunc-routines),$(objpfx)$(f)$(o)): sysdep-CFLAGS += -D_F128_ENABLE_IFUNC
endef
object-suffixes-left := $(all-object-suffixes)
include $(o-iterator)
# Likewise, but for power9.
include $(o-iterator)
define o-iterator-doit
$(foreach f,$(f128-march-routines-p9),$(objpfx)$(f)$(o)): sysdep-CFLAGS += $$(enable-f128-ifunc-CFLAGS) -mcpu=power9
endef
object-suffixes-left := $(all-object-suffixes)
include $(o-iterator)
endif # do_f128_multiarch
endif

56
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128-ifunc-macros.h Normal file
View File

@ -0,0 +1,56 @@
/* _Float128 aliasing macro support for ifunc generation on PPC.
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_IFUNC_MACROS_PPC64LE
#define _FLOAT128_IFUNC_MACROS_PPC64LE 1
/* Bring in the various alias-providing headers, and disable
_Float128 related macros. This prevents exporting any ABI
from _Float128 implementation objects. */
#include <libm-alias-float128.h>
#include <libm-alias-finite.h>
#undef libm_alias_float128_r
#undef libm_alias_finite
#undef libm_alias_exclusive_ldouble
#undef libm_alias_float128_other_r_ldbl
#undef declare_mgen_finite_alias
#undef declare_mgen_alias
#undef declare_mgen_alias_r
#define libm_alias_finite(from, to)
#define libm_alias_float128_r(from, to, r)
#define libm_alias_exclusive_ldouble(from, to)
#define libm_alias_float128_other_r_ldbl(from, to, r)
#define declare_mgen_finite_alias(from, to)
#define declare_mgen_alias(from, to)
#define declare_mgen_alias_r(from, to)
/* Likewise, disable hidden symbol support. This is not needed
for the implementation objects as the redirects already give
us this support. This also means any non-_Float128 headers
which provide hidden_def's should be included prior to this
header (e.g fenv.h). */
#undef libm_hidden_def
#define libm_hidden_def(func)
#undef libm_hidden_proto
#define libm_hidden_proto(f)
#include <float128-ifunc-redirect-macros.h>
#endif /* _FLOAT128_IFUNC_MACROS_PPC64LE */

53
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128-ifunc-redirect-macros.h Normal file
View File

@ -0,0 +1,53 @@
/* _Float128 aliasing macro support for ifunc generation on PPC.
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_IFUNC_REDIRECT_MACROS_PPC64LE
#define _FLOAT128_IFUNC_REDIRECT_MACROS_PPC64LE 1
/* Define the redirection macros used throughout most of the IFUNC headers.
The variant is inferred via compiler options.
F128_REDIR_PFX_R(function, destination_prefix, reentrant_suffix)
Redirect function, optionally suffixed by reentrant_suffix, to a function
named destination_prefix ## function ## variant ## reentrant_suffix.
F128_SFX_APPEND(sym)
Append the the multiarch variant specific suffix to the sym. sym is not
expanded. This is sym ## variant.
F128_REDIR_R(func, reentrant_suffix)
Redirect func to a function named function ## variant ## reentrant_suffix
F128_REDIR(function)
Convience wrapper for F128_REDIR_R where function does not require
a suffix argument.
*/
#ifndef _ARCH_PWR9
#define F128_REDIR_PFX_R(func, pfx, r) \
extern __typeof(func ## r) func ## r __asm( #pfx #func "_power8" #r );
#define F128_SFX_APPEND(x) x ## _power8
#else
#define F128_REDIR_PFX_R(func, pfx, r) \
extern __typeof(func ## r) func ## r __asm( #pfx #func "_power9" #r );
#define F128_SFX_APPEND(x) x ## _power9
#endif
#define F128_REDIR_R(func, r) F128_REDIR_PFX_R (func, , r)
#define F128_REDIR(func) F128_REDIR_R (func, )
#endif /*_FLOAT128_IFUNC_REDIRECT_MACROS_PPC64LE */

64
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128-ifunc-redirects-mp.h Normal file
View File

@ -0,0 +1,64 @@
/* _Float128 multiarch redirects shared with math_private.h
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_IFUNC_REDIRECTS_MP_H
#define _FLOAT128_IFUNC_REDIRECTS_MP_H 1
#include <float128-ifunc-redirect-macros.h>
F128_REDIR (__ieee754_acosf128)
F128_REDIR (__ieee754_acoshf128)
F128_REDIR (__ieee754_asinf128)
F128_REDIR (__ieee754_atan2f128)
F128_REDIR (__ieee754_atanhf128)
F128_REDIR (__ieee754_coshf128)
F128_REDIR (__ieee754_expf128)
F128_REDIR (__ieee754_exp10f128)
F128_REDIR (__ieee754_exp2f128)
F128_REDIR (__ieee754_fmodf128)
F128_REDIR (__ieee754_gammaf128)
F128_REDIR_R (__ieee754_gammaf128, _r)
F128_REDIR (__ieee754_hypotf128)
F128_REDIR (__ieee754_j0f128)
F128_REDIR (__ieee754_j1f128)
F128_REDIR (__ieee754_jnf128)
F128_REDIR (__ieee754_lgammaf128)
F128_REDIR_R (__ieee754_lgammaf128, _r)
F128_REDIR (__ieee754_logf128)
F128_REDIR (__ieee754_log10f128)
F128_REDIR (__ieee754_log2f128)
F128_REDIR (__ieee754_powf128)
F128_REDIR (__ieee754_remainderf128)
F128_REDIR (__ieee754_sinhf128)
F128_REDIR (__ieee754_sqrtf128)
F128_REDIR (__ieee754_y0f128)
F128_REDIR (__ieee754_y1f128)
F128_REDIR (__ieee754_ynf128)
F128_REDIR (__ieee754_scalbf128)
F128_REDIR (__ieee754_ilogbf128)
F128_REDIR (__ieee754_rem_pio2f128)
F128_REDIR (__kernel_sinf128)
F128_REDIR (__kernel_cosf128)
F128_REDIR (__kernel_tanf128)
F128_REDIR (__kernel_sincosf128)
F128_REDIR (__kernel_rem_pio2f128)
F128_REDIR (__x2y2m1f128)
F128_REDIR (__gamma_productf128)
F128_REDIR (__lgamma_negf128)
#endif /*_FLOAT128_IFUNC_REDIRECTS_MP_H */

43
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128-ifunc-redirects.h Normal file
View File

@ -0,0 +1,43 @@
/* _Float128 redirects for ppc64le multiarch env.
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_IFUNC_REDIRECTS
#define _FLOAT128_IFUNC_REDIRECTS 1
#include <float128-ifunc-macros.h>
F128_REDIR_PFX_R (sqrtf128, __,);
F128_REDIR_PFX_R (rintf128, __,);
F128_REDIR_PFX_R (ceilf128, __,);
F128_REDIR_PFX_R (floorf128, __,);
F128_REDIR_PFX_R (truncf128, __,);
F128_REDIR_PFX_R (roundf128, __,);
F128_REDIR_PFX_R (fabsf128, __,);
extern __typeof (ldexpf128) F128_SFX_APPEND (__ldexpf128);
#define __ldexpf128 F128_SFX_APPEND (__ldexpf128)
/* libm_hidden_proto is disabled by the time we reach here.
Ensure some internally called functions are still called
without going through the PLT. Note, this code is only
included when building libm. */
hidden_proto (__fpclassifyf128)
hidden_proto (__issignalingf128)
#endif /* _FLOAT128_IFUNC_REDIRECTS */

166
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128-ifunc.h Normal file
View File

@ -0,0 +1,166 @@
/* _Float128 ifunc ABI/ifunc generation macros.
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_IFUNC_H
#define _FLOAT128_IFUNC_H 1
/* Disable hidden prototypes. These perform function renames which
prevent the ifunc functions from working. */
#undef hidden_proto
#define hidden_proto(x)
#define NO_MATH_REDIRECT 1
/* Include the real math.h to avoid optimizations caused by include/math.h
(e.x fabsf128 prototype is masked by an inline definition).*/
#include <math/math.h>
#include <math_private.h>
#include <complex.h>
#include <first-versions.h>
#include <shlib-compat.h>
#include "init-arch.h"
#include <libm-alias-float128.h>
#include <libm-alias-finite.h>
/* _F128_IFUNC2(func, from, r)
Generate an ifunc symbol func ## r from the symbols
from ## {power8, power9} ## r
We use the PPC hwcap bit HAS_IEEE128 to select between the two with
the assumption all P9 features are available on such targets. */
#define _F128_IFUNC2(func, from, r) \
libc_ifunc (func ## r, (hwcap2 & PPC_FEATURE2_HAS_IEEE128) \
? from ## _power9 ## r : from ## _power8 ## r)
/* _F128_IFUNC(func, r)
Similar to above, except the exported symbol name trivially remaps from
func ## {cpu} ## r to func ## r. */
#define _F128_IFUNC(func, r) _F128_IFUNC2(func, func, r)
/* MAKE_IMPL_IFUNC2(func, pfx1, pfx2, r)
Declare external symbols of type pfx1 ## func ## f128 ## r with the name
pfx2 ## func ## f128 ## _{cpu} ## r
which are exported as implementation specific symbols (i.e backing support
for type classification macros). */
#define MAKE_IMPL_IFUNC2(func, pfx1, pfx2, r) \
extern __typeof (pfx1 ## func ## f128 ## r) pfx2 ## func ## f128_power8 ## r; \
extern __typeof (pfx1 ## func ## f128 ## r) pfx2 ## func ## f128_power9 ## r; \
_F128_IFUNC2 (__ ## func ## f128, pfx2 ## func ## f128, r);
/* GEN_COMPAT_R_e(f)
Generate a compatability symbol for finite alias of ieee function. */
#define GEN_COMPAT_R_e(f, r) \
libm_alias_finite (__ieee754_ ## f ## f128 ## r, __ ## f ## f128 ## r)
#define GEN_COMPAT_e_acos(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_acosh(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_asin(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_sinh(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_atan2(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_atanh(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_cosh(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_exp10(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_exp2(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_exp(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_fmod(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_gamma_r(f) GEN_COMPAT_R_e(f,_r)
#define GEN_COMPAT_e_hypot(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_j0(f) GEN_COMPAT_R_e(f,) GEN_COMPAT_R_e(y0,)
#define GEN_COMPAT_e_j1(f) GEN_COMPAT_R_e(f,) GEN_COMPAT_R_e(y1,)
#define GEN_COMPAT_e_jn(f) GEN_COMPAT_R_e(f,) GEN_COMPAT_R_e(yn,)
#define GEN_COMPAT_e_lgamma_r(f) GEN_COMPAT_R_e(f,_r)
#define GEN_COMPAT_e_log10(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_log2(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_log(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_pow(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_remainder(f) GEN_COMPAT_R_e(f,)
#define GEN_COMPAT_e_sqrt(f) GEN_COMPAT_R_e(f,)
/* MAKE_IEEE_IFUNC_R(func, pfx, r)
Declare an ieee ifunc symbol used internally by libm. E.g __ieee754_sinf128 */
#define MAKE_IEEE_IFUNC_R(func, r) \
extern __typeof (__ieee754_ ## func ## f128 ## r) __ieee754_ ## func ## f128_power8 ## r; \
extern __typeof (__ieee754_ ## func ## f128 ## r) __ieee754_ ## func ## f128_power9 ## r; \
_F128_IFUNC2 (__ieee754_ ## func ## f128, __ieee754_ ## func ## f128, r);
/* MAKE_IFUNCP_WRAP_R(w, func, r)
Export a function which the implementation wraps with prefix w to
to func ## r. */
#define MAKE_IFUNCP_WRAP_R(w, func, r) \
extern __typeof (func ## f128 ## r) __ ## func ## f128 ## r; \
MAKE_IMPL_IFUNC2 (func,__,__ ## w, r) \
weak_alias (__ ## func ## f128 ## r, func ## f128 ## r); \
libm_alias_float128_other_r (__ ## func, func, r);
/* MAKE_IFUNCP_R(func, r)
The default IFUNC generator for all libm _Float128 ABI except
when specifically overwritten. This is a convenience wrapper
around MAKE_IFUNCP_R where w is not used. */
#define MAKE_IFUNCP_R(func,r) MAKE_IFUNCP_WRAP_R (,func,r)
/* Generic aliasing functions. */
#define DECL_ALIAS(f) MAKE_IFUNCP_R (f,)
#define DECL_ALIAS_s(f) MAKE_IFUNCP_R (f,)
#define DECL_ALIAS_w(f) MAKE_IFUNCP_R (f,)
#define DECL_ALIAS_e(f) MAKE_IEEE_IFUNC_R (f,)
#define DECL_ALIAS_k(f)
#define DECL_ALIAS_R_w(f) MAKE_IFUNCP_R (f, _r)
#define DECL_ALIAS_R_e(f) MAKE_IEEE_IFUNC_R (f,_r)
/* No symbols are defined in these helper/wrapper objects. */
#define DECL_ALIAS_lgamma_neg(x)
#define DECL_ALIAS_lgamma_product(x)
#define DECL_ALIAS_gamma_product(x)
#define DECL_ALIAS_x2y2m1(x)
#define DECL_ALIAS_s_log1p(x)
#define DECL_ALIAS_s_scalbln(x)
#define DECL_ALIAS_s_scalbn(x)
/* Ensure the wrapper functions get exposed via IFUNC, not the
wrappee (e.g __w_log1pf128_power8 instead of __log1pf128_power8. */
#define DECL_ALIAS_w_log1p(x) MAKE_IFUNCP_WRAP_R(w_,x,)
#define DECL_ALIAS_w_scalbln(x) MAKE_IFUNCP_WRAP_R(w_,x,)
/* These are declared in their respective jX objects. */
#define DECL_ALIAS_w_j0(f) MAKE_IFUNCP_R (f,) MAKE_IFUNCP_R (y0,)
#define DECL_ALIAS_w_j1(f) MAKE_IFUNCP_R (f,) MAKE_IFUNCP_R (y1,)
#define DECL_ALIAS_w_jn(f) MAKE_IFUNCP_R (f,) MAKE_IFUNCP_R (yn,)
#define DECL_ALIAS_e_j0(f) MAKE_IEEE_IFUNC_R (f,) MAKE_IEEE_IFUNC_R (y0,)
#define DECL_ALIAS_e_j1(f) MAKE_IEEE_IFUNC_R (f,) MAKE_IEEE_IFUNC_R (y1,)
#define DECL_ALIAS_e_jn(f) MAKE_IEEE_IFUNC_R (f,) MAKE_IEEE_IFUNC_R (yn,)
#define DECL_ALIAS_s_erf(f) MAKE_IFUNCP_R (f,) MAKE_IFUNCP_R (erfc,)
/* scalbnf128 is an alias of ldexpf128. */
#define DECL_ALIAS_s_ldexp(f) MAKE_IFUNCP_R (f,) MAKE_IFUNCP_WRAP_R (wrap_, scalbn,)
/* Declare an IFUNC for a symbol which only exists
to provide long double == ieee128 ABI. */
#define DECL_LDOUBLE_ALIAS(func, RTYPE, ARGS) \
extern RTYPE func ARGS; \
extern __typeof (func) func ## _power8; \
extern __typeof (func) func ## _power9; \
_F128_IFUNC ( func,)
/* Handle the special case functions which exist only to support
ldouble == ieee128. */
#define DECL_ALIAS_w_scalb(x) \
DECL_LDOUBLE_ALIAS (__scalbf128,_Float128, (_Float128, _Float128)) \
libm_alias_float128_other_r_ldbl (__scalb, scalb,)
#endif /* ifndef _FLOAT128_IFUNC_H */

99
sysdeps/powerpc/powerpc64/le/fpu/multiarch/float128_private.h Normal file
View File

@ -0,0 +1,99 @@
/* _Float128 overrides for float128 in ppc64le multiarch env.
Copyright (C) 2020 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/>. */
#ifndef _FLOAT128_PRIVATE_PPC64LE
#define _FLOAT128_PRIVATE_PPC64LE 1
#if IS_IN(libc) || !defined(_F128_ENABLE_IFUNC)
/* multiarch is not supported. Do nothing and pass through. */
#include_next <float128_private.h>
#else
/* Include fenv.h now before turning off libm_hidden_proto.
At minimum, fereaiseexcept is needed. */
#include <fenv.h>
/* The PLT bypass trick used by libm_hidden_proto uses asm-renames.
If gcc detects a second rename to a different function, it will
emit errors. */
#undef libm_hidden_proto
#define libm_hidden_proto(f)
/* Always disable redirects. We supply these uniquely later on. */
#undef NO_MATH_REDIRECT
#define NO_MATH_REDIRECT
#include <math.h>
#undef NO_MATH_REDIRECT
#include_next <float128_private.h>
#include <float128-ifunc-macros.h>
/* Declare these now. These prototyes are not included
in any header. */
extern __typeof (cosf128) __ieee754_cosf128;
extern __typeof (asinhf128) __ieee754_asinhf128;
F128_REDIR (__ieee754_asinhf128)
F128_REDIR (__ieee754_cosf128)
F128_REDIR (__asinhf128)
F128_REDIR (__atanf128)
F128_REDIR (__cbrtf128)
F128_REDIR (__ceilf128)
F128_REDIR (__cosf128)
F128_REDIR (__erfcf128)
F128_REDIR (__erff128)
F128_REDIR (__expf128)
F128_REDIR (__expm1f128)
F128_REDIR (__fabsf128)
F128_REDIR (__fdimf128)
F128_REDIR (__floorf128)
F128_REDIR (__fmaf128)
F128_REDIR (__fmaxf128)
F128_REDIR (__fminf128)
F128_REDIR (__frexpf128)
F128_REDIR (__ldexpf128)
F128_REDIR (__llrintf128)
F128_REDIR (__llroundf128)
F128_REDIR (__log1pf128)
F128_REDIR (__logbf128)
F128_REDIR (__logf128)
F128_REDIR (__lrintf128)
F128_REDIR (__lroundf128)
F128_REDIR (__modff128)
F128_REDIR (__nearbyintf128)
F128_REDIR (__remquof128)
F128_REDIR (__rintf128)
F128_REDIR (__roundevenf128)
F128_REDIR (__roundf128)
F128_REDIR (__scalblnf128)
F128_REDIR (__scalbnf128)
F128_REDIR (__sincosf128)
F128_REDIR (__sinf128)
F128_REDIR (__sqrtf128)
F128_REDIR (__tanhf128)
F128_REDIR (__tanf128)
F128_REDIR (__truncf128)
F128_REDIR (__lgamma_productf128)
#include <float128-ifunc-redirects-mp.h>
#include <float128-ifunc-redirects.h>
#endif /* !(IS_IN(libc) && defined(_F128_ENABLE_IFUNC) */
#endif /* _FLOAT128_PRIVATE_PPC64LE */

120
sysdeps/powerpc/powerpc64/le/fpu/multiarch/math-type-macros-float128.h Normal file
View File

@ -0,0 +1,120 @@
/* _Float128 overrides for float128 in ppc64le multiarch env.
Copyright (C) 2020 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/>. */
#ifndef _MATH_TYPE_MACROS_FLOAT128_PPC64_MULTI
#define _MATH_TYPE_MACROS_FLOAT128_PPC64_MULTI 1
#include_next <math-type-macros-float128.h>
#if !IS_IN(libc) && defined(_F128_ENABLE_IFUNC)
/* Include fenv.h now before turning off PLT bypass. At
minimum fereaiseexcept is used today. */
#include <fenv.h>
#include <float128-ifunc-macros.h>
/* Ensure local redirects are always disabled by including
math.h in the following manner. */
#undef NO_MATH_REDIRECT
#define NO_MATH_REDIRECT
#include <math.h>
#undef NO_MATH_REDIRECT
/* Include complex prototypes now to enable redirecting of
complex functions. */
#include <complex.h>
/* Declare redirects for a function f which has a complex
analogue. That is, __ ## f ## f128 and __c ## f ## f128. */
#define F128_C_REDIR(f) F128_REDIR (__c ## f ## f128); \
F128_REDIR (__ ## f ## f128); \
/* Similar to F128_C_REDIR, declare the set of implementation
redirects for the trigonometric family f for {a,}f{,h}
and {a,}cf{,h} complex variants where f is sin/cos/tan. */
#define F128_TRIG_REDIR(f) F128_C_REDIR (a ## f); \
F128_C_REDIR (a ## f ## h); \
F128_C_REDIR (f); \
F128_C_REDIR (f ## h);
F128_TRIG_REDIR (cos)
F128_TRIG_REDIR (sin)
F128_TRIG_REDIR (tan)
F128_C_REDIR (log);
F128_C_REDIR (log10);
F128_C_REDIR (exp);
F128_C_REDIR (sqrt);
F128_C_REDIR (pow);
F128_REDIR (__atan2f128)
F128_REDIR (__kernel_casinhf128);
F128_REDIR (__rintf128);
F128_REDIR (__floorf128);
F128_REDIR (__fabsf128);
F128_REDIR (__hypotf128);
F128_REDIR (__scalbnf128);
F128_REDIR (__scalblnf128);
F128_REDIR (__sincosf128);
F128_REDIR (__log1pf128);
F128_REDIR (__ilogbf128);
F128_REDIR (__ldexpf128);
F128_REDIR (__cargf128);
F128_REDIR (__cimagf128);
F128_REDIR (__crealf128);
F128_REDIR (__conjf128);
F128_REDIR (__cprojf128);
F128_REDIR (__cabsf128);
F128_REDIR (__fdimf128);
F128_REDIR (__fminf128);
F128_REDIR (__fmaxf128);
F128_REDIR (__fmodf128);
F128_REDIR (__llogbf128);
F128_REDIR (__log2f128);
F128_REDIR (__exp10f128);
F128_REDIR (__exp2f128);
F128_REDIR (__j0f128);
F128_REDIR (__j1f128);
F128_REDIR (__jnf128);
F128_REDIR (__y0f128);
F128_REDIR (__y1f128);
F128_REDIR (__ynf128);
F128_REDIR (__lgammaf128);
F128_REDIR_R (__lgammaf128, _r);
F128_REDIR (__tgammaf128);
F128_REDIR (__remainderf128);
/* This is ugly. Some wrapper functions are neither prototyped nor declared
uniformily (for various acceptable reasons). A prototype is supplied
to ensure they are appropriately ifunc'ed. */
extern _Float128 __wrap_scalbnf128 (_Float128, int);
extern _Float128 __w_scalblnf128 (_Float128, long int);
extern _Float128 __w_log1pf128 (_Float128);
extern _Float128 __scalbf128 (_Float128, _Float128);
F128_REDIR (__scalbf128);
F128_REDIR (__wrap_scalbnf128);
F128_REDIR (__w_scalblnf128);
F128_REDIR (__w_log1pf128);
/* Include the redirects shared with math_private.h users. */
#include <float128-ifunc-redirects.h>
#endif /* !IS_IN(libc) && defined(_F128_ENABLE_IFUNC) */
#endif /*_MATH_TYPE_MACROS_FLOAT128_PPC64_MULTI */

15
sysdeps/powerpc/powerpc64/le/fpu/multiarch/math_private.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef MATH_PRIVATE_PPC64LE_MA
#define MATH_PRIVATE_PPC64LE_MA 1
#include_next <math_private.h>
#if defined (_F128_ENABLE_IFUNC)
/* math_private.h redeclares many float128_private.h renamed functions, but
we can't include float128_private.h as this header is used beyond
private float128 files. */
#include <float128-ifunc-redirects-mp.h>
#endif
#endif /* MATH_PRIVATE_PPC64LE_MA */

28
sysdeps/powerpc/powerpc64/le/fpu/multiarch/s_fmaf128-power9.c
View File

@ -1,28 +0,0 @@
/* __fmaf128() PowerPC64LE POWER9 version.
Copyright (C) 2020 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
<http://www.gnu.org/licenses/>. */
#include <libm-alias-float128.h>
#undef libm_alias_float128
#define libm_alias_float128(a, b)
#undef strong_alias
#define strong_alias(a, b)
#define __fmaf128 __fmaf128_power9
#include <sysdeps/ieee754/float128/s_fmaf128.c>

26
sysdeps/powerpc/powerpc64/le/fpu/multiarch/s_fmaf128-ppc64.c
View File

@ -1,26 +0,0 @@
/* __fmaf128() PowerPC64LE version.
Copyright (C) 2020 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
<http://www.gnu.org/licenses/>. */
#undef weak_alias
#define weak_alias(a, b)
#undef strong_alias
#define strong_alias(a, b)
#define __fmaf128 __fmaf128_ppc64
#include <sysdeps/ieee754/float128/s_fmaf128.c>

36
sysdeps/powerpc/powerpc64/le/fpu/multiarch/s_fmaf128.c
View File

@ -1,36 +0,0 @@
/* Multiple versions of fmaf128.
Copyright (C) 2020 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
<http://www.gnu.org/licenses/>. */
#include <libm-alias-float128.h>
#define fmaf128 __redirect_fmaf128
#include <math.h>
#undef fmaf128
#include <math_ldbl_opt.h>
#include "init-arch.h"
extern __typeof (__redirect_fmaf128) __fmaf128_ppc64 attribute_hidden;
extern __typeof (__redirect_fmaf128) __fmaf128_power9 attribute_hidden;
libc_ifunc_redirected (__redirect_fmaf128, __fmaf128,
(hwcap2 & PPC_FEATURE2_HAS_IEEE128)
? __fmaf128_power9
: __fmaf128_ppc64);
libm_alias_float128 (__fma, fma)

35
sysdeps/powerpc/powerpc64/le/fpu/multiarch/w_sqrtf128-power9.c
View File

@ -1,35 +0,0 @@
/* POWER9 sqrt for _Float128
Copyright (C) 2018-2020 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.
In addition to the permissions in the GNU Lesser General Public
License, the Free Software Foundation gives you unlimited
permission to link the compiled version of this file into
combinations with other programs, and to distribute those
combinations without any restriction coming from the use of this
file. (The Lesser General Public License restrictions do apply in
other respects; for example, they cover modification of the file,
and distribution when not linked into a combine executable.)
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 <math-type-macros-float128.h>
#define __sqrtf128 __sqrtf128_power9
#undef declare_mgen_alias
#define declare_mgen_alias(a, b)
#include <w_sqrt_template.c>

35
sysdeps/powerpc/powerpc64/le/fpu/multiarch/w_sqrtf128-ppc64le.c
View File

@ -1,35 +0,0 @@
/* PPC64LE sqrt for _Float128
Copyright (C) 2018-2020 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.
In addition to the permissions in the GNU Lesser General Public
License, the Free Software Foundation gives you unlimited
permission to link the compiled version of this file into
combinations with other programs, and to distribute those
combinations without any restriction coming from the use of this
file. (The Lesser General Public License restrictions do apply in
other respects; for example, they cover modification of the file,
and distribution when not linked into a combine executable.)
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 <math-type-macros-float128.h>
#define __sqrtf128 __sqrtf128_ppc64le
#undef declare_mgen_alias
#define declare_mgen_alias(a, b)
#include <w_sqrt_template.c>

31
sysdeps/powerpc/powerpc64/le/fpu/multiarch/w_sqrtf128.c
View File

@ -1,31 +0,0 @@
/* Multiple versions of __sqrtf128.
Copyright (C) 2018-2020 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/>. */
#define NO_MATH_REDIRECT
#include <math.h>
#include "init-arch.h"
#include <math-type-macros-float128.h>
extern __typeof (__sqrtf128) __sqrtf128_ppc64le attribute_hidden;
extern __typeof (__sqrtf128) __sqrtf128_power9 attribute_hidden;
libc_ifunc (__sqrtf128,
(hwcap2 & PPC_FEATURE2_ARCH_3_00)
? __sqrtf128_power9
: __sqrtf128_ppc64le);
declare_mgen_alias (__sqrt, sqrt)

3
sysdeps/powerpc/powerpc64/le/power9/Makeconfig Normal file
View File

@ -0,0 +1,3 @@
# Hint to multiarch (if used) we support power9
# on powerpc64le.
libc-submachine-power9 = yes