1 # Copyright (C) 1996-2017 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 # <http://www.gnu.org/licenses/>.
18 # Makefile for the math library.
24 # Installed header files.
25 headers
:= math.h bits
/mathcalls.h bits
/mathinline.h bits
/huge_val.h \
26 bits
/huge_valf.h bits
/huge_vall.h bits
/inf.h bits
/nan.h \
27 fpu_control.h complex.h bits
/cmathcalls.h fenv.h \
28 bits
/fenv.h bits
/fenvinline.h bits
/mathdef.h tgmath.h \
29 bits
/math-finite.h bits
/math-vector.h \
30 bits
/libm-simd-decl-stubs.h bits
/iscanonical.h \
31 bits
/flt-eval-method.h bits
/fp-fast.h bits
/fp-logb.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 t_exp 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 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 w_ilogbF w_llogbF \
57 w_log1pF w_scalblnF s_fmaxmagF s_fminmagF w_acosF \
58 w_acoshF w_asinF w_atan2F w_atanhF w_coshF w_exp10F \
59 w_exp2F w_fmodF w_hypotF w_j0F w_j1F w_jnF w_logF \
60 w_log10F w_log2F w_powF w_remainderF w_sinhF w_sqrtF \
61 w_tgammaF w_lgammaF w_lgammaF_r w_expF
64 e_acosF e_acoshF e_asinF e_atan2F e_atanhF e_coshF e_expF e_fmodF \
65 e_hypotF e_j0F e_j1F e_jnF e_lgammaF_r e_logF e_log10F e_powF \
66 e_rem_pio2F e_remainderF e_scalbF e_sinhF e_sqrtF e_gammaF_r \
68 k_cosF k_sinF k_tanF s_asinhF s_atanF s_cbrtF \
69 s_ceilF s_cosF s_erfF s_expm1F s_fabsF \
70 s_floorF s_log1pF s_logbF \
71 s_nextafterF s_nexttowardF s_rintF s_scalblnF \
72 s_significandF s_sinF s_tanF s_tanhF \
73 s_fpclassifyF s_truncF \
74 s_remquoF e_log2F e_exp2F s_roundF s_nearbyintF s_sincosF \
75 s_fmaF s_lrintF s_llrintF s_lroundF s_llroundF e_exp10F \
76 s_issignalingF
$(calls
:s_
%=m_
%) x2y2m1F \
77 gamma_productF lgamma_negF lgamma_productF \
78 s_nextupF s_totalorderF s_totalordermagF s_getpayloadF \
79 s_setpayloadF s_setpayloadsigF s_roundevenF s_fromfpF s_ufromfpF \
80 s_fromfpxF s_ufromfpxF
$(gen-libm-calls
)
83 w_acosF_compat w_acoshF_compat w_asinF_compat w_atan2F_compat \
84 w_atanhF_compat w_coshF_compat w_exp2F_compat w_exp10F_compat \
85 w_fmodF_compat w_hypotF_compat w_j0F_compat w_j1F_compat \
86 w_jnF_compat w_log2F_compat w_log10F_compat w_logF_compat \
87 w_powF_compat w_remainderF_compat w_scalbF_compat \
88 w_sinhF_compat w_sqrtF_compat w_tgammaF_compat \
89 w_lgammaF_r_compat w_lgammaF_compat2 w_expF_compat \
90 w_lgamma_compatF k_standardF
92 # Type specific routine support.
94 # The following three variables control what is included for each type:
96 # type-floatN-suffix = The suffix of the type
97 # type-floatN-routines = Type specific support objects
98 # type-floatN-yes = If the type is supported, evaluates to floatN
100 # Finally, note that types is an intentionally recursive variable.
101 # We only know the full set of supported types for the target machine
102 # after the Rules makefile has been parsed.
103 types
= $(type-ldouble-
$(long-double-fcts
)) double float
105 # long double support
106 type-ldouble-suffix
:= l
107 type-ldouble-routines
:= t_sincosl k_sincosl s_iscanonicall
108 type-ldouble-yes
:= ldouble
111 type-double-suffix
:=
112 type-double-routines
:= branred doasin dosincos halfulp mpa mpatan2 \
113 mpatan mpexp mplog mpsqrt mptan sincos32 slowexp \
114 slowpow sincostab k_rem_pio2
117 type-float-suffix
:= f
118 type-float-routines
:= k_rem_pio2f
121 # Apply suffix to each type in arg 1
122 type-foreach
= $(foreach t
,$(types
),$(subst F
,$(type-
$(t
)-suffix),$(1)))
124 libm-routines
= $(strip $(libm-support
) \
125 $(call type-foreach
, $(libm-compat-calls
)) \
126 $(call type-foreach
, $(libm-calls
)) \
127 $(foreach t
, $(types
), $(type-
$(t
)-routines
))) \
129 # These functions are in libc instead of libm because __printf_fp
130 # calls them, so any program using printf will need them linked in,
131 # and we don't want to have to link every program with -lm.
132 # In libm-calls (above), list m_foo in place of s_foo for any
133 # routine that should be compiled separately for its libc and libm versions.
134 calls
= s_isinfF s_isnanF s_finiteF s_copysignF s_modfF s_scalbnF s_frexpF \
135 s_signbitF
$(gen-calls
)
137 generated
+= $(foreach s
,.c .S
,$(call type-foreach
, $(calls
:s_
%=m_
%$(s
))))
138 routines
= $(call type-foreach
, $(calls
))
140 ifeq ($(build-mathvec
),yes
)
141 # We need to install libm.so and libm.a as linker scripts
142 # for transparent use of vector math library.
143 install-lib-ldscripts
:= libm.so libm.a
144 install-others
= $(inst_libdir
)/libm.so
$(inst_libdir
)/libm.a
145 $(inst_libdir
)/libm.so
: $(common-objpfx
)format.lds \
149 (echo
'/* GNU ld script'; echo
'*/';\
151 echo
'GROUP ( $(slibdir)/libm.so$(libm.so-version) ' \
152 'AS_NEEDED ( $(libdir)/libmvec_nonshared.a $(slibdir)/libmvec.so$(libmvec.so-version) ) )' \
156 $(inst_libdir
)/libm-
$(version
).a
: $(objpfx
)libm.a \
160 $(inst_libdir
)/libm.a
: $(common-objpfx
)format.lds \
161 $(inst_libdir
)/libm-
$(version
).a \
162 $(objpfx
)..
/mathvec
/libmvec.a \
164 (echo
'/* GNU ld script'; echo
'*/';\
166 echo
'GROUP ( $(libdir)/libm-$(version).a $(libdir)/libmvec.a )' \
171 # Rules for the test suite.
172 tests
= test-matherr test-fenv atest-exp atest-sincos atest-exp2 basic-test \
173 test-misc test-fpucw test-fpucw-ieee tst-definitions test-tgmath \
174 test-tgmath-ret bug-nextafter bug-nexttoward bug-tgmath1 \
175 test-tgmath-int test-tgmath2 test-powl tst-CMPLX tst-CMPLX2 test-snan \
176 test-fenv-tls test-fenv-preserve test-fenv-return test-fenvinline \
177 test-nearbyint-except test-fenv-clear test-signgam-finite \
178 test-signgam-finite-c99 test-signgam-finite-c11 \
179 test-nearbyint-except-2 test-signgam-uchar test-signgam-uchar-init \
180 test-signgam-uint test-signgam-uint-init test-signgam-ullong \
181 test-signgam-ullong-init test-nan-overflow test-nan-payload \
182 test-fexcept test-fexcept-traps test-fesetexcept \
183 test-fesetexcept-traps test-fetestexceptflag test-femode \
184 test-femode-traps test-iszero-excess-precision \
185 test-iseqsig-excess-precision test-flt-eval-method \
186 test-fp-ilogb-constants test-fp-llogb-constants \
187 test-fe-snans-always-signal
$(tests-static
)
188 tests-static
= test-fpucw-static test-fpucw-ieee-static \
189 test-signgam-uchar-static test-signgam-uchar-init-static \
190 test-signgam-uint-static test-signgam-uint-init-static \
191 test-signgam-ullong-static test-signgam-ullong-init-static
194 tests
+= test-math-isinff test-math-iszero
198 libm-vec-tests
= $(addprefix test-
,$(libmvec-tests
))
199 libm-test-support
= $(foreach t
,$(types
),libm-test-support-
$(t
))
200 test-extras
+= $(libm-test-support
)
201 extra-test-objs
+= $(addsuffix .o
, $(libm-test-support
))
202 libm-vec-test-wrappers
= $(addsuffix -wrappers
, $(libm-vec-tests
))
203 test-extras
+= $(libm-vec-test-wrappers
)
204 extra-test-objs
+= $(addsuffix .o
, $(libm-vec-test-wrappers
))
206 ulps-file
= $(firstword $(wildcard $(sysdirs
:%=%/libm-test-ulps
)))
208 $(objpfx
)libm-test-ulps.h
: $(ulps-file
) gen-libm-test.pl
209 $(make-target-directory
)
210 $(PERL
) gen-libm-test.pl
-u
$< -H
$@
212 libm-test-funcs-auto
= acos acosh asin asinh atan atan2 atanh cabs cacos \
213 cacosh carg casin casinh catan catanh cbrt ccos ccosh \
214 cexp clog clog10 cos cosh cpow csin csinh csqrt ctan \
215 ctanh erf erfc exp exp10 exp2 expm1 fma hypot j0 j1 jn \
216 lgamma log log10 log1p log2 pow sin sincos sinh sqrt \
217 tan tanh tgamma y0 y1 yn
218 libm-test-funcs-noauto
= canonicalize ceil cimag conj copysign cproj creal \
219 fabs fdim floor fmax fmaxmag fmin fminmag fmod \
220 fpclassify frexp fromfp fromfpx getpayload ilogb \
221 iscanonical iseqsig isfinite isgreater \
222 isgreaterequal isinf isless islessequal \
223 islessgreater isnan isnormal issignaling issubnormal \
224 isunordered iszero llogb llrint llround logb lrint \
225 lround modf nearbyint nextafter nextdown nexttoward \
226 nextup remainder remquo rint round roundeven scalb \
227 scalbln scalbn setpayload setpayloadsig signbit \
228 significand totalorder totalordermag trunc ufromfp \
230 libm-test-funcs-all
= $(libm-test-funcs-auto
) $(libm-test-funcs-noauto
)
231 libm-test-c-auto
= $(foreach f
,$(libm-test-funcs-auto
),libm-test-
$(f
).c
)
232 libm-test-c-noauto
= $(foreach f
,$(libm-test-funcs-noauto
),libm-test-
$(f
).c
)
233 generated
+= libm-test-ulps.h
$(libm-test-c-auto
) $(libm-test-c-noauto
)
235 libm-tests-base-normal
= $(foreach t
,$(types
),test-
$(t
))
236 libm-tests-base-finite
= $(foreach t
,$(types
),test-
$(t
)-finite
)
237 libm-tests-base-inline
= $(foreach t
,$(types
),test-i
$(t
))
238 libm-tests-base
= $(libm-tests-base-normal
) $(libm-tests-base-finite
) \
239 $(libm-tests-base-inline
) $(libm-vec-tests
)
240 libm-tests-normal
= $(foreach t
,$(libm-tests-base-normal
),\
241 $(foreach f
,$(libm-test-funcs-all
),\
243 libm-tests-finite
= $(foreach t
,$(libm-tests-base-finite
),\
244 $(foreach f
,$(libm-test-funcs-all
),\
246 libm-tests-inline
= $(foreach t
,$(libm-tests-base-inline
),\
247 $(foreach f
,$(libm-test-funcs-all
),\
249 libm-tests-vector
= $(foreach t
,$(libmvec-tests
),\
250 $(foreach f
,$($(t
)-funcs
),test-
$(t
)-$(f
)))
251 libm-tests
= $(libm-tests-normal
) $(libm-tests-finite
) $(libm-tests-inline
) \
253 libm-tests-for-type
= $(foreach f
,$(libm-test-funcs-all
),\
254 test-
$(1)-$(f
) test-
$(1)-finite-
$(f
) \
256 $(filter test-
$(1)-%,$(libm-tests-vector
))
258 libm-tests.o
= $(addsuffix .o
,$(libm-tests
))
260 tests
+= $(libm-tests
)
261 generated
+= $(addsuffix .c
,$(libm-tests
)) \
262 $(foreach t
,$(types
),libm-test-support-
$(t
).c
)
264 libm-test-c-auto-obj
= $(addprefix $(objpfx
),$(libm-test-c-auto
))
265 libm-test-c-noauto-obj
= $(addprefix $(objpfx
),$(libm-test-c-noauto
))
267 $(libm-test-c-noauto-obj
): $(objpfx
)libm-test
%.c
: libm-test
%.inc \
269 $(make-target-directory
)
270 $(PERL
) gen-libm-test.pl
-c
$< -a
/dev
/null
-C
$@
272 $(libm-test-c-auto-obj
): $(objpfx
)libm-test
%.c
: libm-test
%.inc \
275 $(make-target-directory
)
276 $(PERL
) gen-libm-test.pl
-c
$< -a auto-libm-test-out
$* -C
$@
278 libm-test-incs
= $(foreach f
,$(libm-test-funcs-all
),libm-test-
$(f
).inc
)
281 libm-test-fast-math-cflags
= -fno-builtin
-D__FAST_MATH__
-DTEST_FAST_MATH
282 libm-test-vec-cflags
= $(libm-test-fast-math-cflags
) -fno-inline \
283 -ffloat-store
-D_OPENMP
=201307 -Wno-unknown-pragmas
285 CFLAGS-test-double-vlen4-wrappers.c
= $(double-vlen4-arch-ext-cflags
)
287 CFLAGS-test-double-vlen8-wrappers.c
= $(double-vlen8-arch-ext-cflags
)
289 CFLAGS-test-float-vlen8-wrappers.c
= $(float-vlen8-arch-ext-cflags
)
291 CFLAGS-test-float-vlen16-wrappers.c
= $(float-vlen16-arch-ext-cflags
)
293 # The no-inline tests use -fsignaling-nans, and thereby use the
294 # versions of classification macros that support sNaNs. The inline
295 # function tests use the versions of classification macros that may
296 # raise spurious exceptions for sNaNs, but also do not test for
297 # exceptions. Thus both versions of the classification macros are
299 libm-test-no-inline-cflags
= -fno-inline
-ffloat-store
-fno-builtin \
301 libm-test-finite-cflags
= $(libm-test-no-inline-cflags
) \
302 -U__FINITE_MATH_ONLY__
-D__FINITE_MATH_ONLY__
=1
303 libm-test-inline-cflags
= $(libm-test-fast-math-cflags
)
304 CFLAGS-test-tgmath.c
= -fno-builtin
305 # The following testcase uses very long lines (>3 million), so it may take a
306 # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
307 # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54402
308 CFLAGS-test-tgmath2.c
= -fno-builtin
309 CFLAGS-test-tgmath-ret.c
= -fno-builtin
310 CFLAGS-test-powl.c
= -fno-builtin
312 CFLAGS-test-snan.c
= -fsignaling-nans
314 CFLAGS-test-signgam-finite.c
= -ffinite-math-only
315 CFLAGS-test-signgam-finite-c99.c
= -ffinite-math-only
-std
=c99
316 CFLAGS-test-signgam-finite-c11.c
= -ffinite-math-only
-std
=c11
317 CFLAGS-test-signgam-uchar.c
= -std
=c99
318 CFLAGS-test-signgam-uchar-init.c
= -std
=c99
319 CFLAGS-test-signgam-uchar-static.c
= -std
=c99
320 CFLAGS-test-signgam-uchar-init-static.c
= -std
=c99
321 CFLAGS-test-signgam-uint.c
= -std
=c99
322 CFLAGS-test-signgam-uint-init.c
= -std
=c99
323 CFLAGS-test-signgam-uint-static.c
= -std
=c99
324 CFLAGS-test-signgam-uint-init-static.c
= -std
=c99
325 CFLAGS-test-signgam-ullong.c
= -std
=c99
326 CFLAGS-test-signgam-ullong-init.c
= -std
=c99
327 CFLAGS-test-signgam-ullong-static.c
= -std
=c99
328 CFLAGS-test-signgam-ullong-init-static.c
= -std
=c99
330 CFLAGS-test-math-isinff.
cc = -std
=gnu
++11
331 CFLAGS-test-math-iszero.
cc = -std
=gnu
++11
333 CFLAGS-test-iszero-excess-precision.c
= -fexcess-precision
=standard
334 CFLAGS-test-iseqsig-excess-precision.c
= -fexcess-precision
=standard
335 CFLAGS-test-flt-eval-method.c
= -fexcess-precision
=standard
337 CFLAGS-test-fe-snans-always-signal.c
= -fsignaling-nans
339 # The -lieee module sets the _LIB_VERSION_ switch to IEEE mode
340 # for error handling in the -lm functions.
341 install-lib
+= libieee.a
342 non-lib.a
+= libieee.a
343 extra-objs
+= libieee.a ieee-math.o
347 gen-all-calls
= $(gen-libm-calls
) $(gen-calls
)
349 generated
+= $(addsuffix .c
,$(call type-foreach
,$(gen-all-calls
))) \
350 gen-libm-templates.stmp
352 # Create wrappers in the math build directory.
353 $(objpfx
)gen-libm-templates.stmp
: Makefile
354 $(make-target-directory
)
355 for gcall in
$(gen-all-calls
); do \
356 func
=$${gcall
%F
*}$${gcall
#*F}; \
357 for type in
$(foreach t
,$(types
),$(t
)__
$(type-
$(t
)-suffix)); do \
360 file
=$(objpfx
)$${gcall
%F
*}$${suff}$${gcall
#*F}.c; \
362 echo
"#include <math-type-macros-$${type}.h>"; \
363 echo
"#include <$${func}_template.c>"; \
369 # Add dependency to ensure the generator runs prior.
370 $(foreach t
, $(call type-foreach
, $(gen-all-calls
)), \
371 $(objpfx
)$(t
).c
): $(objpfx
)gen-libm-templates.stmp
374 # This must come after the inclusion of sysdeps Makefiles via Rules.
376 $(foreach t
,$(libm-tests-normal
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
378 type
=$${type_func
%%-*}; \
379 func
=$${type_func
#*-}; \
381 echo
"#include <test-$$type.h>"; \
382 echo
"#include <test-math-no-finite.h>"; \
383 echo
"#include <test-math-no-inline.h>"; \
384 echo
"#include <test-math-errno.h>"; \
385 echo
"#include <test-math-scalar.h>"; \
386 echo
"#include <libm-test-$$func.c>"; \
389 $(foreach t
,$(libm-tests-finite
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
391 type
=$${type_func
%%-*}; \
392 func
=$${type_func
#*-finite-}; \
394 echo
"#include <test-$$type.h>"; \
395 echo
"#include <test-math-finite.h>"; \
396 echo
"#include <test-math-no-inline.h>"; \
397 echo
"#include <test-math-scalar.h>"; \
398 echo
"#include <libm-test-$$func.c>"; \
401 $(foreach t
,$(libm-tests-inline
),$(objpfx
)$(t
).c
): $(objpfx
)test-i
%.c
:
403 type
=$${type_func
%%-*}; \
404 func
=$${type_func
#*-}; \
406 echo
"#include <test-$$type.h>"; \
407 echo
"#include <test-math-inline.h>"; \
408 echo
"#include <test-math-scalar.h>"; \
409 echo
"#include <libm-test-$$func.c>"; \
412 $(foreach t
,$(libm-tests-vector
),$(objpfx
)$(t
).c
): $(objpfx
)test-
%.c
:
414 type
=$${type_func
%-*}; \
415 func
=$${type_func
##*-}; \
416 func_args
=$$(grep ALL_RM_TEST libm-test-
$$func.inc \
417 | sed
's/.*RUN_TEST_LOOP_//;s/_.*//'); \
419 echo
"#include <test-$$type.h>"; \
420 echo
"WRAPPER_DECL_$$func_args (WRAPPER_NAME (FUNC ($$func)))"; \
421 echo
"#include <libm-test-$$func.c>"; \
424 $(foreach t
,$(types
),\
425 $(objpfx
)libm-test-support-
$(t
).c
): $(objpfx
)libm-test-support-
%.c
:
427 echo
"#include <test-$*.h>"; \
428 echo
"#include <libm-test-support.c>"; \
431 $(addprefix $(objpfx
), $(libm-tests.o
)): $(objpfx
)libm-test-ulps.h
433 define o-iterator-doit
434 $(foreach f
,$(libm-test-funcs-all
),\
435 $(objpfx
)$(o
)-$(f
).o
): $(objpfx
)$(o
)%.o
: $(objpfx
)libm-test
%.c
437 object-suffixes-left
:= $(libm-tests-base
)
438 include $(o-iterator
)
440 define o-iterator-doit
441 $(foreach f
,$(libm-test-funcs-all
),\
442 $(objpfx
)$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-no-inline-cflags
)
444 object-suffixes-left
:= $(libm-tests-base-normal
)
445 include $(o-iterator
)
447 define o-iterator-doit
448 $(foreach f
,$(libm-test-funcs-all
),\
449 $(objpfx
)$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-finite-cflags
)
451 object-suffixes-left
:= $(libm-tests-base-finite
)
452 include $(o-iterator
)
454 define o-iterator-doit
455 $(foreach f
,$(libm-test-funcs-all
),\
456 $(objpfx
)$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-inline-cflags
)
458 object-suffixes-left
:= $(libm-tests-base-inline
)
459 include $(o-iterator
)
461 define o-iterator-doit
462 $(foreach f
,$($(o
)-funcs
),\
463 $(objpfx
)test-
$(o
)-$(f
).o
): CFLAGS
+= $(libm-test-vec-cflags
)
465 object-suffixes-left
:= $(libmvec-tests
)
466 include $(o-iterator
)
468 define o-iterator-doit
469 $(addprefix $(objpfx
),\
470 $(call libm-tests-for-type
,$(o
))): $(objpfx
)libm-test-support-
$(o
).o
472 object-suffixes-left
:= $(types
)
473 include $(o-iterator
)
475 define o-iterator-doit
476 $(objpfx
)libm-test-support-
$(o
).o
: CFLAGS
+= $(libm-test-no-inline-cflags
)
478 object-suffixes-left
:= $(types
)
479 include $(o-iterator
)
481 # Run the math programs to automatically generate ULPs files.
484 run-regen-ulps
= $(test-wrapper-env
) \
486 $($*-ENV
) $(rtld-prefix
) $${run}
488 regen-ulps
: $(addprefix $(objpfx
),$(libm-tests
))
489 rm -f
$(objpfx
)ULPs
; rm -f
$(objpfx
)NewUlps
; \
490 cp
$(ulps-file
) $(objpfx
)libm-test-ulps
; \
492 echo
"Regenerating ULPs for $${run}"; \
493 $(run-regen-ulps
) -u
-o
$(objpfx
); \
494 cat
$(objpfx
)ULPs
>> $(objpfx
)libm-test-ulps
; \
497 $(PERL
) gen-libm-test.pl
-n
$(objpfx
)NewUlps \
498 -u
$(objpfx
)libm-test-ulps
; \
499 echo
"Automatic regeneration of ULPs complete."; \
500 echo
"Difference between the current baseline and the new baseline is:";\
501 diff
-urN
$(ulps-file
) $(objpfx
)NewUlps
; \
502 echo
"Copy $(objpfx)NewUlps to $(ulps-file) (relative to source)."
505 @echo
"Automatic regeneration of ULPs requires perl."; \
509 # The generated sysd-rules file defines rules like this for sources
510 # coming from sysdeps/ directories. These rules find the generic sources.
511 define o-iterator-doit
512 $(objpfx
)m_
%$o: s_
%.c
$(before-compile
); $$(compile-command.c
)
514 object-suffixes-left
:= $(all-object-suffixes
)
515 include $(o-iterator
)
517 # Likewise, for those generated files shared with libc.
518 define o-iterator-doit
519 $(objpfx
)m_
%$o: $(objpfx
)s_
%.c
$(before-compile
); $$(compile-command.c
)
521 object-suffixes-left
:= $(all-object-suffixes
)
522 include $(o-iterator
)
524 # This file defines the default _LIB_VERSION variable that controls
525 # the error return conventions for the math functions.
526 CPPFLAGS-s_lib_version.c
:= -D_POSIX_MODE
528 # We don't want the fdlibm code to use the inline math functions,
529 # only the fdlibm code.
530 math-CPPFLAGS
+= -D__NO_MATH_INLINES
-D__LIBC_INTERNAL_MATH_INLINES
532 ifneq ($(long-double-fcts
),yes
)
533 # The `double' and `long double' types are the same on this machine.
534 # We won't compile the `long double' code at all. Tell the `double' code
535 # to define aliases for the `FUNCl' names. To avoid type conflicts in
536 # defining those aliases, tell <math.h> to declare the `FUNCl' names with
537 # `double' instead of `long double'.
538 math-CPPFLAGS
+= -DNO_LONG_DOUBLE
-D_Mlong_double_
=double
541 # These files quiet sNaNs in a way that is optimized away without
543 CFLAGS-s_modf.c
+= -fsignaling-nans
544 CFLAGS-s_modff.c
+= -fsignaling-nans
545 CFLAGS-s_modfl.c
+= -fsignaling-nans
547 # The -lieee library is actually an object file.
548 # The module just defines the _LIB_VERSION_ variable.
549 # It's not a library to make sure it is linked in instead of s_lib_version.o.
550 $(objpfx
)libieee.a
: $(objpfx
)ieee-math.o
552 $(patsubst %/,cd
% &&,$(objpfx
)) \
555 $(addprefix $(objpfx
),\
556 $(filter-out $(tests-static
) $(libm-tests-vector
),\
558 $(addprefix $(objpfx
),$(tests-static
)): $(objpfx
)libm.a
559 define o-iterator-doit
560 $(foreach f
,$($(o
)-funcs
),\
561 $(objpfx
)test-
$(o
)-$(f
)): $(objpfx
)test-
$(o
)-wrappers.o \
564 object-suffixes-left
:= $(libmvec-tests
)
565 include $(o-iterator
)
567 gmp-objs
= $(patsubst %,$(common-objpfx
)stdlib
/%.o
,\
568 add_n sub_n cmp addmul_1 mul_1 mul_n divmod_1 \
569 lshift rshift mp_clz_tab udiv_qrnnd inlines \
570 $(gmp-sysdep_routines
))
571 $(objpfx
)atest-exp
: $(gmp-objs
)
572 $(objpfx
)atest-sincos
: $(gmp-objs
)
573 $(objpfx
)atest-exp2
: $(gmp-objs
)
574 $(objpfx
)test-fenv-tls
: $(shared-thread-library
)