1 # Copyright (C) 1996-2021 Free Software Foundation, Inc.
2 # This file is part of the GNU C Library.
4 # The GNU C Library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # The GNU C Library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with the GNU C Library; if not, see
16 # <https://www.gnu.org/licenses/>.
18 # Makefile for the math library.
24 # Installed header files.
25 headers
:= math.h bits
/mathcalls.h \
26 fpu_control.h complex.h bits
/cmathcalls.h fenv.h \
27 bits
/fenv.h bits
/mathdef.h tgmath.h \
28 bits
/math-vector.h finclude
/math-vector-fortran.h \
29 bits
/libm-simd-decl-stubs.h bits
/iscanonical.h \
30 bits
/flt-eval-method.h bits
/fp-fast.h bits
/fp-logb.h \
31 bits
/long-double.h bits
/mathcalls-helper-functions.h \
32 bits
/floatn.h bits
/floatn-common.h bits
/mathcalls-narrow.h
35 aux
:= setfpucw fpu_control
37 # Build the -lm library.
40 extra-libs-others
= $(extra-libs
)
42 libm-support
= s_lib_version s_matherr s_signgam \
43 fclrexcpt fgetexcptflg fraiseexcpt fsetexcptflg \
44 ftestexcept fegetround fesetround fegetenv feholdexcpt \
45 fesetenv feupdateenv fedisblxcpt feenablxcpt \
46 fegetexcept fesetexcept fetestexceptflag fegetmode \
49 # Wrappers for these functions generated per type using a file named
50 # <func>_template.c and the appropriate math-type-macros-<TYPE>.h.
51 gen-libm-calls
= cargF conjF cimagF crealF cabsF e_scalbF s_cacosF \
52 s_cacoshF s_ccosF s_ccoshF s_casinF s_csinF s_casinhF \
53 k_casinhF s_csinhF k_casinhF s_csinhF s_catanhF s_catanF \
54 s_ctanF s_ctanhF s_cexpF s_clogF s_cprojF s_csqrtF \
55 s_cpowF s_clog10F s_fdimF s_nextdownF s_fmaxF s_fminF \
56 s_nanF s_iseqsigF s_canonicalizeF s_significandF \
58 w_log1pF w_scalblnF s_fmaxmagF s_fminmagF w_acosF \
59 w_acoshF w_asinF w_atan2F w_atanhF w_coshF w_exp10F \
60 w_exp2F w_fmodF w_hypotF w_j0F w_j1F w_jnF w_logF \
61 w_log10F w_log2F w_powF w_remainderF w_scalbF \
63 w_tgammaF w_lgammaF w_lgammaF_r w_expF e_exp2F
66 e_acosF e_acoshF e_asinF e_atan2F e_atanhF e_coshF e_expF e_fmodF \
67 e_hypotF e_j0F e_j1F e_jnF e_lgammaF_r e_logF e_log10F e_powF \
68 e_remainderF e_sinhF e_sqrtF e_gammaF_r \
70 k_tanF s_asinhF s_atanF s_cbrtF \
71 s_ceilF s_cosF s_erfF s_expm1F s_fabsF \
72 s_floorF s_log1pF s_logbF \
73 s_nextafterF s_nexttowardF s_rintF s_scalblnF \
74 s_sinF s_tanF s_tanhF \
75 s_fpclassifyF s_truncF \
76 s_remquoF e_log2F s_roundF s_nearbyintF s_sincosF \
77 s_fmaF s_lrintF s_llrintF s_lroundF s_llroundF e_exp10F \
78 s_issignalingF
$(calls
:s_
%=m_
%) x2y2m1F \
79 gamma_productF lgamma_negF lgamma_productF \
80 s_nextupF s_totalorderF s_totalordermagF s_getpayloadF \
81 s_setpayloadF s_setpayloadsigF s_roundevenF s_fromfpF s_ufromfpF \
82 s_fromfpxF s_ufromfpxF
$(gen-libm-calls
)
85 w_acosF_compat w_acoshF_compat w_asinF_compat w_atan2F_compat \
86 w_atanhF_compat w_coshF_compat w_exp2F_compat w_exp10F_compat \
87 w_fmodF_compat w_hypotF_compat w_j0F_compat w_j1F_compat \
88 w_jnF_compat w_log2F_compat w_log10F_compat w_logF_compat \
89 w_powF_compat w_remainderF_compat w_scalbF_compat \
90 w_sinhF_compat w_sqrtF_compat w_tgammaF_compat \
91 w_lgammaF_r_compat w_lgammaF_compat2 w_expF_compat \
92 w_lgamma_compatF k_standardF
94 libm-narrow-fns
= add div mul sub
95 libm-narrow-types-basic
= s_fF s_f32xFf64
96 libm-narrow-types-ldouble-yes
= s_fFl s_dFl
97 libm-narrow-types-float128-yes
= s_f32Ff128 s_f64Ff128 s_f64xFf128
98 libm-narrow-types-float128-alias-yes
= s_f64xFf128
99 libm-narrow-types
= $(libm-narrow-types-basic
) \
100 $(libm-narrow-types-ldouble-
$(long-double-fcts
)) \
101 $(libm-narrow-types-float128-
$(float128-fcts
)) \
102 $(libm-narrow-types-float128-alias-
$(float128-alias-fcts
))
104 # Type specific routine support.
106 # The following three variables control what is included for each type:
108 # type-floatN-suffix = The suffix of the type
109 # type-floatN-routines = Type specific support objects
110 # type-floatN-yes = If the type is supported, evaluates to floatN
112 # Finally, note that types is an intentionally recursive variable.
113 # We only know the full set of supported types for the target machine
114 # after the Rules makefile has been parsed.
115 types-basic
= $(type-ldouble-
$(long-double-fcts
)) double float
117 # Like types, but includes types whose functions alias those for
119 test-types-basic
= ldouble double float
121 # long double support
122 type-ldouble-suffix
:= l
123 type-ldouble-routines
:= t_sincosl k_sinl k_cosl k_sincosl s_iscanonicall \
125 type-ldouble-yes
:= ldouble
128 type-double-suffix
:=
129 type-double-routines
:= branred k_rem_pio2 \
130 sincostab math_err e_exp_data e_log_data \
131 e_log2_data e_pow_log_data
134 type-float-suffix
:= f
135 type-float-routines
:= math_errf e_exp2f_data e_logf_data \
136 e_log2f_data e_powf_log2_data s_sincosf_data
139 type-float128-suffix
:= f128
140 type-float128-routines
:= t_sincosf128 k_sinf128 k_cosf128 k_sincosf128 \
142 type-float128-yes
:= float128
144 # _Float64x may be supported, only as an alias type.
145 type-float64x-yes
:= float64x
147 # IBM long double support in additional to IEEE 128 long double support
148 type-ibm128-suffix
:= l
149 type-ibm128-yes
:= ibm128
151 types
= $(types-basic
) $(type-float128-
$(float128-fcts
))
152 test-types
= $(test-types-basic
) $(type-float128-
$(float128-fcts
)) \
153 float32 float64
$(type-float128-
$(float128-alias-fcts
)) \
154 float32x
$(type-float64x-
$(float64x-alias-fcts
)) \
155 $(type-ibm128-
$(ibm128-fcts
))
157 # Pairs of types for which narrowing functions should be tested (this
158 # variable has more entries than libm-narrow-types because it includes
159 # pairs for which the functions sometimes or always alias functions
160 # for other types). This definition embeds the assumption that if
161 # _Float64x is supported, so is _Float128, and vice versa (they may or
162 # may not have the same format).
163 test-type-pairs
= float-double float-ldouble double-ldouble \
164 float32-float64 float32-float32x float32x-float64 \
165 $(test-type-pairs-f64xf128-
$(float128-fcts
)) \
166 $(test-type-pairs-f64xf128-
$(float128-alias-fcts
))
167 test-type-pairs-f64xf128-yes
= float32-float64x float32-float128 \
168 float64-float64x float64-float128 \
169 float32x-float64x float32x-float128 \
172 # For each of the basic types (float, double, long double), replace the
173 # occurrences of 'F' in arg 1 with the appropriate suffix for the type.
174 type-basic-foreach
= $(foreach t
, $(types-basic
), \
175 $(subst F
,$(type-
$(t
)-suffix),$(1)))
177 # Apply suffix to each type in arg 1
178 type-foreach
= $(foreach t
,$(types
),$(subst F
,$(type-
$(t
)-suffix),$(1)))
180 libm-routines
= $(strip $(libm-support
) \
181 $(call type-basic-foreach
, \
182 $(libm-compat-calls
)) \
183 $(call type-foreach
, $(libm-calls
)) \
184 $(foreach t
, $(types
), $(type-
$(t
)-routines
))) \
185 $(foreach f
,$(libm-narrow-fns
), \
186 $(subst F
,$(f
),$(libm-narrow-types
)))
188 # These functions are in libc instead of libm because __printf_fp
189 # calls them, so any program using printf will need them linked in,
190 # and we don't want to have to link every program with -lm.
191 # In libm-calls (above), list m_foo in place of s_foo for any
192 # routine that should be compiled separately for its libc and libm versions.
193 calls
= s_isinfF s_isnanF s_finiteF s_copysignF s_modfF s_scalbnF s_frexpF \
194 s_signbitF
$(gen-calls
)
196 generated
+= $(foreach s
,.c .S
,$(call type-foreach
, $(calls
:s_
%=m_
%$(s
))))
197 routines
= $(call type-foreach
, $(calls
))
198 # The $(calls) that are shared between libm and libc are not included in static
199 # libm so the symbols end up in exactly one place.
200 libm-shared-only-routines
= $(call type-foreach
, $(calls
:s_
%=m_
%))
202 ifeq ($(build-mathvec
),yes
)
203 # We need to install libm.so and libm.a as linker scripts
204 # for transparent use of vector math library.
205 install-lib-ldscripts
:= libm.so libm.a
206 install-others
= $(inst_libdir
)/libm.so
$(inst_libdir
)/libm.a
207 $(inst_libdir
)/libm.so
: $(common-objpfx
)format.lds \
211 (echo
'/* GNU ld script'; echo
'*/';\
213 echo
'GROUP ( $(slibdir)/libm.so$(libm.so-version) ' \
214 'AS_NEEDED ( $(slibdir)/libmvec.so$(libmvec.so-version) ) )' \
218 $(inst_libdir
)/libm-
$(version
).a
: $(objpfx
)libm.a \
222 $(inst_libdir
)/libm.a
: $(common-objpfx
)format.lds \
223 $(inst_libdir
)/libm-
$(version
).a \
224 $(objpfx
)..
/mathvec
/libmvec.a \
226 (echo
'/* GNU ld script'; echo
'*/';\
228 echo
'GROUP ( $(libdir)/libm-$(version).a $(libdir)/libmvec.a )' \
233 # Rules for the test suite.
234 tests
= test-matherr-3 test-fenv basic-test \
235 test-misc test-fpucw test-fpucw-ieee tst-definitions test-tgmath \
236 test-tgmath-ret bug-nextafter bug-nexttoward bug-tgmath1 \
237 test-tgmath-int test-tgmath2 test-powl tst-CMPLX tst-CMPLX2 test-snan \
238 test-fenv-tls test-fenv-preserve test-fenv-return \
239 test-nearbyint-except test-fenv-clear \
240 test-nearbyint-except-2 test-signgam-uchar test-signgam-uchar-init \
241 test-signgam-uint test-signgam-uint-init test-signgam-ullong \
242 test-signgam-ullong-init test-nan-overflow test-nan-payload \
243 test-fexcept test-fexcept-traps test-fesetexcept \
244 test-fesetexcept-traps test-fetestexceptflag test-femode \
245 test-femode-traps test-iszero-excess-precision \
246 test-iseqsig-excess-precision test-flt-eval-method \
247 test-fp-ilogb-constants test-fp-llogb-constants \
248 test-fe-snans-always-signal test-narrow-macros \
249 test-nan-const
$(tests-static
)
250 tests-static
= test-fpucw-static test-fpucw-ieee-static \
251 test-signgam-uchar-static test-signgam-uchar-init-static \
252 test-signgam-uint-static test-signgam-uint-init-static \
253 test-signgam-ullong-static test-signgam-ullong-init-static
255 # The tested symbols matherr, _LIB_VERSION have been removed in glibc 2.27.
256 ifeq ($(have-GLIBC_2.26
)$(build-shared
),yesyes
)
257 tests
+= test-matherr test-matherr-2
260 # These tests use internal (unexported) GMP functions and are linked
261 # statically to obtain access to these functions.
262 tests-static
+= atest-exp atest-sincos atest-exp2
265 tests
+= test-math-isinff test-math-iszero test-math-issignaling \
266 test-math-iscanonical test-math-cxx11 test-math-iseqsig
269 libm-vec-tests
= $(addprefix test-
,$(libmvec-tests
))
270 libm-test-support
= $(foreach t
,$(test-types
),libm-test-support-
$(t
))
271 test-extras
+= $(libm-test-support
)
272 extra-test-objs
+= $(addsuffix .o
, $(libm-test-support
))
273 libm-vec-test-wrappers
= $(addsuffix -wrappers
, $(libm-vec-tests
))
274 test-extras
+= $(libm-vec-test-wrappers
)
275 extra-test-objs
+= $(addsuffix .o
, $(libm-vec-test-wrappers
))
277 ulps-file
= $(firstword $(wildcard $(sysdirs
:%=%/libm-test-ulps
)))
279 $(objpfx
)libm-test-ulps.h
: $(ulps-file
) gen-libm-test.py
280 $(make-target-directory
)
281 $(PYTHON
) gen-libm-test.py
-u
$< -H
$@
283 libm-test-funcs-auto
= acos acosh asin asinh atan atan2 atanh cabs cacos \
284 cacosh carg casin casinh catan catanh cbrt ccos ccosh \
285 cexp clog clog10 cos cosh cpow csin csinh csqrt ctan \
286 ctanh erf erfc exp exp10 exp2 expm1 fma hypot j0 j1 jn \
287 lgamma log log10 log1p log2 pow sin sincos sinh sqrt \
288 tan tanh tgamma y0 y1 yn
289 libm-test-funcs-noauto
= canonicalize ceil cimag conj copysign cproj creal \
290 fabs fdim floor fmax fmaxmag fmin fminmag fmod \
291 fpclassify frexp fromfp fromfpx getpayload ilogb \
292 iscanonical iseqsig isfinite isgreater \
293 isgreaterequal isinf isless islessequal \
294 islessgreater isnan isnormal issignaling issubnormal \
295 isunordered iszero llogb llrint llround logb lrint \
296 lround modf nearbyint nextafter nextdown nexttoward \
297 nextup remainder remquo rint round roundeven scalb \
298 scalbln scalbn setpayload setpayloadsig signbit \
299 significand totalorder totalordermag trunc ufromfp \
300 ufromfpx compat_totalorder compat_totalordermag
301 libm-test-funcs-compat
= compat_totalorder compat_totalordermag
302 libm-test-funcs-narrow
= add div mul sub
303 libm-test-funcs-all
= $(libm-test-funcs-auto
) $(libm-test-funcs-noauto
)
304 libm-test-c-auto
= $(foreach f
,$(libm-test-funcs-auto
),libm-test-
$(f
).c
)
305 libm-test-c-noauto
= $(foreach f
,$(libm-test-funcs-noauto
),libm-test-
$(f
).c
)
306 libm-test-c-narrow
= $(foreach f
,$(libm-test-funcs-narrow
),\
307 libm-test-narrow-
$(f
).c
)
308 generated
+= libm-test-ulps.h
$(libm-test-c-auto
) $(libm-test-c-noauto
) \
309 $(libm-test-c-narrow
)
311 libm-tests-base-normal
= $(foreach t
,$(test-types
),test-
$(t
))
312 libm-tests-base-narrow
= $(foreach t
,$(test-type-pairs
),test-
$(t
))
313 libm-tests-base
= $(libm-tests-base-normal
) $(libm-vec-tests
)
314 libm-tests-normal
= $(foreach t
,$(libm-tests-base-normal
),\
315 $(foreach f
,$(libm-test-funcs-all
),\
317 libm-tests-narrow
= $(foreach t
,$(libm-tests-base-narrow
),\
318 $(foreach f
,$(libm-test-funcs-narrow
),\
320 libm-tests-vector
= $(foreach t
,$(libmvec-tests
),\
321 $(foreach f
,$($(t
)-funcs
),test-
$(t
)-$(f
)))
322 libm-tests
= $(libm-tests-normal
) $(libm-tests-narrow
) $(libm-tests-vector
)
323 libm-tests-compat
= $(foreach t
,$(libm-tests-base-normal
) \
324 $(libm-tests-base-finite
),\
325 $(foreach f
,$(libm-test-funcs-compat
),\
327 libm-tests-for-type
= $(foreach f
,$(libm-test-funcs-all
),\
328 test-
$(1)-$(f
) test-i
$(1)-$(f
)) \
329 $(filter test-
$(1)-%,$(libm-tests-vector
) \
330 $(libm-tests-narrow
))
332 libm-tests.o
= $(addsuffix .o
,$(libm-tests
))
334 tests
+= $(libm-tests
)
335 generated
+= $(addsuffix .c
,$(libm-tests
)) \
336 $(foreach t
,$(test-types
),libm-test-support-
$(t
).c
)
338 libm-test-c-auto-obj
= $(addprefix $(objpfx
),$(libm-test-c-auto
))
339 libm-test-c-noauto-obj
= $(addprefix $(objpfx
),$(libm-test-c-noauto
))
340 libm-test-c-narrow-obj
= $(addprefix $(objpfx
),$(libm-test-c-narrow
))
342 $(libm-test-c-noauto-obj
): $(objpfx
)libm-test
%.c
: libm-test
%.inc \
344 $(make-target-directory
)
345 $(PYTHON
) gen-libm-test.py
-c
$< -a
/dev
/null
-C
$@
347 $(libm-test-c-auto-obj
): $(objpfx
)libm-test
%.c
: libm-test
%.inc \
350 $(make-target-directory
)
351 $(PYTHON
) gen-libm-test.py
-c
$< -a auto-libm-test-out
$* -C
$@
353 $(libm-test-c-narrow-obj
): $(objpfx
)libm-test
%.c
: libm-test
%.inc \
356 $(make-target-directory
)
357 $(PYTHON
) gen-libm-test.py
-c
$< -a auto-libm-test-out
$* -C
$@
359 # Tests for totalorder compat symbols reuse the table of tests as
360 # processed by gen-libm-test.py, so add dependencies on the generated
362 $(foreach t
,$(libm-tests-base
),\
363 $(objpfx
)$(t
)-compat_totalorder.o
): $(objpfx
)libm-test-totalorder.c
365 $(foreach t
,$(libm-tests-base
),\
366 $(objpfx
)$(t
)-compat_totalordermag.o
): $(objpfx
)libm-test-totalordermag.c
368 # _Float128x omitted as not supported by gen-tgmath-tests.py.
369 tgmath3-narrow-types
= f d f16 f32 f64 f128 f32x f64x
370 tgmath3-narrow-macros
= $(foreach t
,$(tgmath3-narrow-types
), \
371 $(foreach f
,$(libm-narrow-fns
),$(t
)$(f
)))
372 tgmath3-macros
= atan2 cbrt ceil copysign erf erfc exp2 expm1 fdim floor \
373 fma fmax fmin fmod frexp hypot ilogb ldexp lgamma llrint \
374 llround log10 log1p log2 logb lrint lround nearbyint \
375 nextafter nexttoward remainder remquo rint round scalbn \
376 scalbln tgamma trunc acos asin atan acosh asinh atanh cos \
377 sin tan cosh sinh tanh exp log pow sqrt fabs carg cimag conj \
378 cproj creal roundeven nextup nextdown fminmag fmaxmag llogb \
379 fromfp fromfpx ufromfp ufromfpx scalb
$(tgmath3-narrow-macros
)
380 tgmath3-macro-tests
= $(addprefix test-tgmath3-
,$(tgmath3-macros
))
381 tests
+= $(tgmath3-macro-tests
)
382 generated
+= $(addsuffix .c
,$(tgmath3-macro-tests
))
384 $(tgmath3-macro-tests
:%=$(objpfx
)%.o
): CFLAGS
+= -fno-builtin
386 $(foreach m
,$(tgmath3-macros
),\
387 $(objpfx
)test-tgmath3-
$(m
).c
): $(objpfx
)test-tgmath3-
%.c
: \
389 $(PYTHON
) gen-tgmath-tests.py
$* > $@
391 # Verify that the list of supported macros is in sync between the
392 # Makefile and gen-tgmath-tests.py.
393 tests-special
+= $(objpfx
)test-tgmath3-macro-list.out
394 $(objpfx
)test-tgmath3-macro-list.out
: gen-tgmath-tests.py
395 $(PYTHON
) $< check-list
$(tgmath3-macros
) > $@
; \
398 libm-test-fast-math-cflags
= -fno-builtin
-D__FAST_MATH__
-DTEST_FAST_MATH
399 libm-test-vec-cflags
= $(libm-test-fast-math-cflags
) -fno-inline \
400 -ffloat-store
-D_OPENMP
=201307 -Wno-unknown-pragmas
402 CFLAGS-test-double-vlen4-wrappers.c
+= $(double-vlen4-arch-ext-cflags
)
404 CFLAGS-test-double-vlen8-wrappers.c
+= $(double-vlen8-arch-ext-cflags
)
406 CFLAGS-test-float-vlen8-wrappers.c
+= $(float-vlen8-arch-ext-cflags
)
408 CFLAGS-test-float-vlen16-wrappers.c
+= $(float-vlen16-arch-ext-cflags
)
410 # The no-inline tests use -fsignaling-nans, and thereby use the
411 # versions of classification macros that support sNaNs. The inline
412 # function tests use the versions of classification macros that may
413 # raise spurious exceptions for sNaNs, but also do not test for
414 # exceptions. Thus both versions of the classification macros are
416 libm-test-no-inline-cflags
= -fno-inline
-ffloat-store
-fno-builtin \
418 CFLAGS-test-tgmath.c
+= -fno-builtin
419 # The following testcase uses very long lines (>3 million), so it may take a
420 # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
421 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54402
422 CFLAGS-test-tgmath2.c
+= -fno-builtin
423 CFLAGS-test-tgmath-ret.c
+= -fno-builtin
424 CFLAGS-test-powl.c
+= -fno-builtin
426 CFLAGS-test-snan.c
+= -fsignaling-nans
428 CFLAGS-test-signgam-uchar.c
+= -std
=c99
429 CFLAGS-test-signgam-uchar-init.c
+= -std
=c99
430 CFLAGS-test-signgam-uchar-static.c
+= -std
=c99
431 CFLAGS-test-signgam-uchar-init-static.c
+= -std
=c99
432 CFLAGS-test-signgam-uint.c
+= -std
=c99
433 CFLAGS-test-signgam-uint-init.c
+= -std
=c99
434 CFLAGS-test-signgam-uint-static.c
+= -std
=c99
435 CFLAGS-test-signgam-uint-init-static.c
+= -std
=c99
436 CFLAGS-test-signgam-ullong.c
+= -std
=c99
437 CFLAGS-test-signgam-ullong-init.c
+= -std
=c99
438 CFLAGS-test-signgam-ullong-static.c
+= -std
=c99
439 CFLAGS-test-signgam-ullong-init-static.c
+= -std
=c99
441 CFLAGS-test-math-cxx11.
cc += -std
=c
++11
443 CFLAGS-test-math-isinff.
cc += -std
=gnu
++11
444 CFLAGS-test-math-iszero.
cc += -std
=gnu
++11
445 CFLAGS-test-math-issignaling.
cc += -std
=gnu
++11
446 CFLAGS-test-math-iscanonical.
cc += -std
=gnu
++11
448 CFLAGS-test-iszero-excess-precision.c
+= -fexcess-precision
=standard
449 CFLAGS-test-iseqsig-excess-precision.c
+= -fexcess-precision
=standard
450 CFLAGS-test-flt-eval-method.c
+= -fexcess-precision
=standard
452 CFLAGS-test-fe-snans-always-signal.c
+= -fsignaling-nans
454 CFLAGS-test-nan-const.c
+= -fno-builtin
458 gen-all-calls
= $(gen-libm-calls
) $(gen-calls
)
460 generated
+= $(addsuffix .c
,$(call type-foreach
,$(gen-all-calls
))) \
461 gen-libm-templates.stmp
463 # Create wrappers in the math build directory.
464 $(objpfx
)gen-libm-templates.stmp
: Makefile
465 $(make-target-directory
)
466 for gcall in
$(gen-all-calls
); do \
467 func
=$${gcall
%F
*}$${gcall
#*F}; \
468 for type in
$(foreach t
,$(types
),$(t
)__
$(type-
$(t
)-suffix)); do \
471 file
=$(objpfx
)$${gcall
%F
*}$${suff}$${gcall
#*F}.c; \
473 echo
"#include <math-type-macros-$${type}.h>"; \
474 echo
"#include <$${func}_template.c>"; \
480 # Add dependency to ensure the generator runs prior.
481 $(foreach t
, $(call type-foreach
, $(gen-all-calls
)), \
482 $(objpfx
)$(t
).c
): $(objpfx
)gen-libm-templates.stmp
484 # This must come after the inclusion of sysdeps Makefiles via Rules.
486 $(foreach t
,$(libm-tests-normal
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
488 type
=$${type_func
%%-*}; \
489 func
=$${type_func
#*-}; \
491 echo
"#include <test-$$type.h>"; \
492 echo
"#include <test-math-exceptions.h>"; \
493 echo
"#include <test-math-errno.h>"; \
494 echo
"#include <test-math-scalar.h>"; \
495 echo
"#include <libm-test-$$func.c>"; \
498 $(foreach t
,$(libm-tests-narrow
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
500 type_pair
=$${type_pair_func
%-*}; \
501 func
=$${type_pair_func
##*-}; \
502 ret_type
=$${type_pair
%%-*}; \
503 arg_type
=$${type_pair
#*-}; \
505 echo
"#include <test-$$ret_type.h>"; \
506 echo
"#include <test-arg-$$arg_type.h>"; \
507 echo
"#include <test-math-exceptions.h>"; \
508 echo
"#include <test-math-errno.h>"; \
509 echo
"#include <test-math-narrow.h>"; \
510 echo
"#include <libm-test-narrow-$$func.c>"; \
513 $(foreach t
,$(libm-tests-vector
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
515 type
=$${type_func
%-*}; \
516 func
=$${type_func
##*-}; \
517 func_args
=$$(grep ALL_RM_TEST libm-test-
$$func.inc \
518 | sed
's/.*RUN_TEST_LOOP_//;s/_.*//'); \
520 echo
"#include <test-$$type.h>"; \
521 echo
"WRAPPER_DECL_$$func_args (WRAPPER_NAME (FUNC ($$func)))"; \
522 echo
"#include <libm-test-$$func.c>"; \
525 $(foreach t
,$(test-types
),\
526 $(objpfx
)libm-test-support-
$(t
).c
): $(objpfx
)libm-test-support-
%.c
:
528 echo
"#include <test-$*.h>"; \
529 echo
"#include <libm-test-support.c>"; \
532 $(addprefix $(objpfx
), $(libm-tests.o
)): $(objpfx
)libm-test-ulps.h
534 define o-iterator-doit
535 $(foreach f
,$(libm-test-funcs-all
),\
536 $(objpfx
)$(o
)-$(f
).o
): $(objpfx
)$(o
)%.o
: $(objpfx
)libm-test
%.c
538 object-suffixes-left
:= $(libm-tests-base
)
539 include $(o-iterator
)
541 define o-iterator-doit
542 $(foreach f
,$(libm-test-funcs-narrow
),\
543 $(objpfx
)$(o
)-$(f
).o
): $(objpfx
)$(o
)%.o
: \
544 $(objpfx
)libm-test-narrow
%.c
546 object-suffixes-left
:= $(libm-tests-base-narrow
)
547 include $(o-iterator
)
549 define o-iterator-doit
550 $(foreach f
,$(libm-test-funcs-all
),\
551 $(objpfx
)$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-no-inline-cflags
)
553 object-suffixes-left
:= $(libm-tests-base-normal
)
554 include $(o-iterator
)
556 define o-iterator-doit
557 $(foreach f
,$(libm-test-funcs-narrow
),\
558 $(objpfx
)$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-no-inline-cflags
)
560 object-suffixes-left
:= $(libm-tests-base-narrow
)
561 include $(o-iterator
)
563 define o-iterator-doit
564 $(foreach f
,$($(o
)-funcs
),\
565 $(objpfx
)test-
$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-vec-cflags
)
567 object-suffixes-left
:= $(libmvec-tests
)
568 include $(o-iterator
)
570 define o-iterator-doit
571 $(addprefix $(objpfx
),\
572 $(call libm-tests-for-type
,$(o
))): $(objpfx
)libm-test-support-
$(o
).o
574 object-suffixes-left
:= $(test-types
)
575 include $(o-iterator
)
577 define o-iterator-doit
578 $(objpfx
)libm-test-support-
$(o
).o
: CFLAGS
+= $(libm-test-no-inline-cflags
)
580 object-suffixes-left
:= $(test-types
)
581 include $(o-iterator
)
583 # Run the math programs to automatically generate ULPs files.
586 run-regen-ulps
= $(test-wrapper-env
) \
588 $($*-ENV
) $(rtld-prefix
) $(objpfx
)$${run}
590 regen-ulps
: $(addprefix $(objpfx
),$(libm-tests
))
591 rm -f
$(objpfx
)ULPs
; rm -f
$(objpfx
)NewUlps
; \
592 cp
$(ulps-file
) $(objpfx
)libm-test-ulps
; \
593 for run in
$(libm-tests
); do \
594 echo
"Regenerating ULPs for $${run}"; \
595 $(run-regen-ulps
) -u
-o
$(objpfx
); \
596 cat
$(objpfx
)ULPs
>> $(objpfx
)libm-test-ulps
; \
599 $(PYTHON
) gen-libm-test.py
-n
$(objpfx
)NewUlps \
600 -u
$(objpfx
)libm-test-ulps
; \
601 echo
"Automatic regeneration of ULPs complete."; \
602 echo
"Difference between the current baseline and the new baseline is:";\
603 diff
-urN
$(ulps-file
) $(objpfx
)NewUlps
; \
604 echo
"Copy $(objpfx)NewUlps to $(ulps-file) (relative to source)."
606 # The generated sysd-rules file defines rules like this for sources
607 # coming from sysdeps/ directories. These rules find the generic sources.
608 define o-iterator-doit
609 $(objpfx
)m_
%$o: s_
%.c
$(before-compile
); $$(compile-command.c
)
611 object-suffixes-left
:= $(all-object-suffixes
)
612 include $(o-iterator
)
614 # Likewise, for those generated files shared with libc.
615 define o-iterator-doit
616 $(objpfx
)m_
%$o: $(objpfx
)s_
%.c
$(before-compile
); $$(compile-command.c
)
618 object-suffixes-left
:= $(all-object-suffixes
)
619 include $(o-iterator
)
621 ifneq ($(long-double-fcts
),yes
)
622 # The `double' and `long double' types are the same on this machine.
623 # We won't compile the `long double' code at all. Tell the `double' code
624 # to define aliases for the `FUNCl' names.
625 math-CPPFLAGS
+= -DNO_LONG_DOUBLE
626 # GCC 10 diagnoses aliases with types conflicting with built-in
628 CFLAGS-w_acos.c
+= -fno-builtin-acosl
629 CFLAGS-w_acosh.c
+= -fno-builtin-acoshl
630 CFLAGS-w_asin.c
+= -fno-builtin-asinl
631 CFLAGS-s_asinh.c
+= -fno-builtin-asinhl
632 CFLAGS-s_atan.c
+= -fno-builtin-atanl
633 CFLAGS-w_atan2.c
+= -fno-builtin-atan2l
634 CFLAGS-w_atanh.c
+= -fno-builtin-atanhl
635 CFLAGS-s_cabs.c
+= -fno-builtin-cabsl
636 CFLAGS-s_cacos.c
+= -fno-builtin-cacosl
637 CFLAGS-s_cacosh.c
+= -fno-builtin-cacoshl
638 CFLAGS-s_canonicalize.c
+= -fno-builtin-canonicalizel
639 CFLAGS-s_carg.c
+= -fno-builtin-cargl
640 CFLAGS-s_casin.c
+= -fno-builtin-casinl
641 CFLAGS-s_casinh.c
+= -fno-builtin-casinhl
642 CFLAGS-s_catan.c
+= -fno-builtin-catanl
643 CFLAGS-s_catanh.c
+= -fno-builtin-catanhl
644 CFLAGS-s_cbrt.c
+= -fno-builtin-cbrtl
645 CFLAGS-s_ccos.c
+= -fno-builtin-ccosl
646 CFLAGS-s_ccosh.c
+= -fno-builtin-ccoshl
647 CFLAGS-s_ceil.c
+= -fno-builtin-ceill
648 CFLAGS-s_cexp.c
+= -fno-builtin-cexpl
649 CFLAGS-s_cimag.c
+= -fno-builtin-cimagl
650 CFLAGS-s_clog.c
+= -fno-builtin-clogl
651 CFLAGS-s_clog10.c
+= -fno-builtin-clog10l
652 CFLAGS-s_conj.c
+= -fno-builtin-conjl
653 CFLAGS-s_copysign.c
+= -fno-builtin-copysignl
654 CFLAGS-s_cos.c
+= -fno-builtin-cosl
655 CFLAGS-w_cosh.c
+= -fno-builtin-coshl
656 CFLAGS-s_cpow.c
+= -fno-builtin-cpowl
657 CFLAGS-s_cproj.c
+= -fno-builtin-cprojl
658 CFLAGS-s_creal.c
+= -fno-builtin-creall
659 CFLAGS-s_csin.c
+= -fno-builtin-csinl
660 CFLAGS-s_csinh.c
+= -fno-builtin-csinhl
661 CFLAGS-s_csqrt.c
+= -fno-builtin-csqrtl
662 CFLAGS-s_ctan.c
+= -fno-builtin-ctanl
663 CFLAGS-s_ctanh.c
+= -fno-builtin-ctanhl
664 CFLAGS-s_dadd.c
+= -fno-builtin-daddl
665 CFLAGS-s_ddiv.c
+= -fno-builtin-ddivl
666 CFLAGS-s_dmul.c
+= -fno-builtin-dmull
667 CFLAGS-s_dsub.c
+= -fno-builtin-dsubl
668 CFLAGS-s_erf.c
+= -fno-builtin-erfl
669 CFLAGS-s_erfc.c
+= -fno-builtin-erfcl
670 CFLAGS-e_exp.c
+= -fno-builtin-expl
671 CFLAGS-w_exp10.c
+= -fno-builtin-exp10l
672 CFLAGS-e_exp2.c
+= -fno-builtin-exp2l
673 CFLAGS-s_expm1.c
+= -fno-builtin-expm1l
674 CFLAGS-s_fabs.c
+= -fno-builtin-fabsl
675 CFLAGS-s_fadd.c
+= -fno-builtin-faddl
676 CFLAGS-s_fdim.c
+= -fno-builtin-fdiml
677 CFLAGS-s_fdiv.c
+= -fno-builtin-fdivl
678 CFLAGS-s_finite.c
+= -fno-builtin-finitel
679 CFLAGS-s_floor.c
+= -fno-builtin-floorl
680 CFLAGS-s_fma.c
+= -fno-builtin-fmal
681 CFLAGS-s_fmax.c
+= -fno-builtin-fmaxl
682 CFLAGS-s_fmaxmag.c
+= -fno-builtin-fmaxmagl
683 CFLAGS-s_fmin.c
+= -fno-builtin-fminl
684 CFLAGS-s_fminmag.c
+= -fno-builtin-fminmagl
685 CFLAGS-w_fmod.c
+= -fno-builtin-fmodl
686 CFLAGS-s_fmul.c
+= -fno-builtin-fmull
687 CFLAGS-s_frexp.c
+= -fno-builtin-frexpl
688 CFLAGS-s_fromfp.c
+= -fno-builtin-fromfpl
689 CFLAGS-s_fromfpx.c
+= -fno-builtin-fromfpxl
690 CFLAGS-s_fsub.c
+= -fno-builtin-fsubl
691 CFLAGS-s_gamma.c
+= -fno-builtin-gammal
692 CFLAGS-s_getpayload.c
+= -fno-builtin-getpayloadl
693 CFLAGS-w_hypot.c
+= -fno-builtin-hypotl
694 CFLAGS-w_ilogb.c
+= -fno-builtin-ilogbl
695 CFLAGS-s_isinf.c
+= -fno-builtin-isinfl
696 CFLAGS-s_isnan.c
+= -fno-builtin-isnanl
697 CFLAGS-w_j0.c
+= -fno-builtin-j0l
698 CFLAGS-w_j1.c
+= -fno-builtin-j1l
699 CFLAGS-w_jn.c
+= -fno-builtin-jnl
700 CFLAGS-s_ldexp.c
+= -fno-builtin-ldexpl
701 CFLAGS-w_lgamma.c
+= -fno-builtin-lgammal
702 CFLAGS-w_lgamma_r.c
+= -fno-builtin-lgammal_r
703 CFLAGS-w_llogb.c
+= -fno-builtin-llogbl
704 CFLAGS-s_llrint.c
+= -fno-builtin-llrintl
705 CFLAGS-s_llround.c
+= -fno-builtin-llroundl
706 CFLAGS-e_log.c
+= -fno-builtin-logl
707 CFLAGS-w_log10.c
+= -fno-builtin-log10l
708 CFLAGS-w_log1p.c
+= -fno-builtin-log1pl
709 CFLAGS-e_log2.c
+= -fno-builtin-log2l
710 CFLAGS-s_logb.c
+= -fno-builtin-logbl
711 CFLAGS-s_lrint.c
+= -fno-builtin-lrintl
712 CFLAGS-s_lround.c
+= -fno-builtin-lroundl
713 CFLAGS-s_modf.c
+= -fno-builtin-modfl
714 CFLAGS-s_nan.c
+= -fno-builtin-nanl
715 CFLAGS-s_nearbyint.c
+= -fno-builtin-nearbyintl
716 CFLAGS-s_nextafter.c
+= -fno-builtin-nextafterl
717 CFLAGS-s_nextdown.c
+= -fno-builtin-nextdownl
718 CFLAGS-s_nexttoward.c
+= -fno-builtin-nexttoward
-fno-builtin-nexttowardl
719 CFLAGS-s_nexttowardf.c
+= -fno-builtin-nexttowardf
720 CFLAGS-s_nextup.c
+= -fno-builtin-nextupl
721 CFLAGS-e_pow.c
+= -fno-builtin-powl
722 CFLAGS-w_remainder.c
+= -fno-builtin-remainderl
-fno-builtin-dreml
723 CFLAGS-s_remquo.c
+= -fno-builtin-remquol
724 CFLAGS-s_rint.c
+= -fno-builtin-rintl
725 CFLAGS-s_round.c
+= -fno-builtin-roundl
726 CFLAGS-s_roundeven.c
+= -fno-builtin-roundevenl
727 CFLAGS-w_scalb.c
+= -fno-builtin-scalbl
728 CFLAGS-w_scalbln.c
+= -fno-builtin-scalblnl
729 CFLAGS-s_scalbn.c
+= -fno-builtin-scalbnl
730 CFLAGS-s_setpayload.c
+= -fno-builtin-setpayloadl
731 CFLAGS-s_setpayloadsig.c
+= -fno-builtin-setpayloadsigl
732 CFLAGS-s_significand.c
+= -fno-builtin-significandl
733 CFLAGS-s_sin.c
+= -fno-builtin-sinl
734 CFLAGS-s_sincos.c
+= -fno-builtin-sincosl
735 CFLAGS-w_sinh.c
+= -fno-builtin-sinhl
736 CFLAGS-w_sqrt.c
+= -fno-builtin-sqrtl
737 CFLAGS-s_tan.c
+= -fno-builtin-tanl
738 CFLAGS-s_tanh.c
+= -fno-builtin-tanhl
739 CFLAGS-w_tgamma.c
+= -fno-builtin-tgammal
740 CFLAGS-s_totalorder.c
+= -fno-builtin-totalorderl
741 CFLAGS-s_totalordermag.c
+= -fno-builtin-totalordermagl
742 CFLAGS-s_trunc.c
+= -fno-builtin-truncl
743 CFLAGS-s_ufromfp.c
+= -fno-builtin-ufromfpl
744 CFLAGS-s_ufromfpx.c
+= -fno-builtin-ufromfpxl
745 CFLAGS-s_y0.c
+= -fno-builtin-y0l
746 CFLAGS-s_y1.c
+= -fno-builtin-y1l
747 CFLAGS-s_yn.c
+= -fno-builtin-ynl
750 # These files quiet sNaNs in a way that is optimized away without
752 CFLAGS-s_modf.c
+= -fsignaling-nans
753 CFLAGS-s_modff.c
+= -fsignaling-nans
754 CFLAGS-s_modfl.c
+= -fsignaling-nans
755 CFLAGS-s_modff128.c
+= -fsignaling-nans
757 $(addprefix $(objpfx
),\
758 $(filter-out $(tests-static
) $(libm-tests-vector
),\
759 $(tests
) $(tests-internal
))): $(libm
)
760 $(addprefix $(objpfx
),$(tests-static
)): $(objpfx
)libm.a
761 define o-iterator-doit
762 $(foreach f
,$($(o
)-funcs
),\
763 $(objpfx
)test-
$(o
)-$(f
)): $(objpfx
)test-
$(o
)-wrappers.o \
766 object-suffixes-left
:= $(libmvec-tests
)
767 include $(o-iterator
)
769 $(objpfx
)test-fenv-tls
: $(shared-thread-library
)