1 # Copyright (C) 1996-2016 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
34 aux
:= setfpucw fpu_control
36 # Build the -lm library.
39 extra-libs-others
= $(extra-libs
)
41 libm-support
= s_lib_version s_matherr s_signgam \
42 fclrexcpt fgetexcptflg fraiseexcpt fsetexcptflg \
43 ftestexcept fegetround fesetround fegetenv feholdexcpt \
44 fesetenv feupdateenv t_exp fedisblxcpt feenablxcpt \
45 fegetexcept fesetexcept fetestexceptflag fegetmode \
48 # Wrappers for these functions generated per type using a file named
49 # <func>_template.c and the appropriate math-type-macros-<TYPE>.h.
50 gen-libm-calls
= cargF conjF cimagF crealF cabsF s_cacosF \
51 s_cacoshF s_ccosF s_ccoshF s_casinF s_csinF s_casinhF \
52 k_casinhF s_csinhF k_casinhF s_csinhF s_catanhF s_catanF \
53 s_ctanF s_ctanhF s_cexpF s_clogF s_cprojF s_csqrtF \
54 s_cpowF s_clog10F s_fdimF s_nextdownF s_fmaxF s_fminF \
55 s_nanF s_iseqsigF s_canonicalizeF w_ilogbF
58 e_acosF e_acoshF e_asinF e_atan2F e_atanhF e_coshF e_expF e_fmodF \
59 e_hypotF e_j0F e_j1F e_jnF e_lgammaF_r e_logF e_log10F e_powF \
60 e_rem_pio2F e_remainderF e_scalbF e_sinhF e_sqrtF e_gammaF_r \
62 k_cosF k_sinF k_tanF s_asinhF s_atanF s_cbrtF \
63 s_ceilF s_cosF s_erfF s_expm1F s_fabsF \
64 s_floorF s_log1pF w_log1pF s_logbF \
65 s_nextafterF s_nexttowardF s_rintF s_scalblnF w_scalblnF \
66 s_significandF s_sinF s_tanF s_tanhF w_acosF w_acoshF w_asinF \
67 w_atan2F w_atanhF w_coshF w_expF w_exp2F w_exp10F w_fmodF \
68 w_tgammaF w_hypotF w_j0F w_j1F w_jnF w_lgammaF w_lgammaF_r \
69 w_logF w_log10F w_powF w_remainderF w_scalbF w_sinhF w_sqrtF \
70 s_fpclassifyF s_truncF \
71 s_remquoF e_log2F e_exp2F s_roundF s_nearbyintF s_sincosF \
72 s_fmaF s_lrintF s_llrintF s_lroundF s_llroundF e_exp10F w_log2F \
73 s_issignalingF
$(calls
:s_
%=m_
%) x2y2m1F \
74 gamma_productF lgamma_negF lgamma_productF \
75 s_nextupF s_totalorderF s_totalordermagF s_getpayloadF \
76 s_setpayloadF s_setpayloadsigF
$(gen-libm-calls
)
78 libm-compat-calls-ldouble-yes
= w_lgamma_compatl k_standardl
79 libm-compat-calls
= w_lgamma_compatf w_lgamma_compat k_standard k_standardf \
80 $(libm-compat-calls-ldouble-
$(long-double-fcts
))
83 # Type specific routine support.
85 # The following three variables control what is included for each type:
87 # type-floatN-suffix = The suffix of the type
88 # type-floatN-routines = Type specific support objects
89 # type-floatN-yes = If the type is supported, evaluates to floatN
91 # Finally, note that types is an intentionally recursive variable.
92 # We only know the full set of supported types for the target machine
93 # after the Rules makefile has been parsed.
94 types
= $(type-ldouble-
$(long-double-fcts
)) double float
97 type-ldouble-suffix
:= l
98 type-ldouble-routines
:= t_sincosl k_sincosl s_iscanonicall
99 type-ldouble-yes
:= ldouble
102 type-double-suffix
:=
103 type-double-routines
:= branred doasin dosincos halfulp mpa mpatan2 \
104 mpatan mpexp mplog mpsqrt mptan sincos32 slowexp \
105 slowpow sincostab k_rem_pio2
108 type-float-suffix
:= f
109 type-float-routines
:= k_rem_pio2f
112 # Apply suffix to each type in arg 1
113 type-foreach
= $(foreach t
,$(types
),$(subst F
,$(type-
$(t
)-suffix),$(1)))
115 libm-routines
= $(strip $(libm-support
) $(libm-compat-calls
) \
116 $(call type-foreach
, $(libm-calls
)) \
117 $(foreach t
, $(types
), $(type-
$(t
)-routines
))) \
119 # These functions are in libc instead of libm because __printf_fp
120 # calls them, so any program using printf will need them linked in,
121 # and we don't want to have to link every program with -lm.
122 # In libm-calls (above), list m_foo in place of s_foo for any
123 # routine that should be compiled separately for its libc and libm versions.
124 calls
= s_isinfF s_isnanF s_finiteF s_copysignF s_modfF s_scalbnF s_frexpF \
125 s_signbitF
$(gen-calls
)
127 generated
+= $(foreach s
,.c .S
,$(call type-foreach
, $(calls
:s_
%=m_
%$(s
))))
128 routines
= $(call type-foreach
, $(calls
))
130 ifeq ($(build-mathvec
),yes
)
131 # We need to install libm.so as linker script
132 # for more comfortable use of vector math library.
133 install-lib-ldscripts
:= libm.so
134 install_subdir
: $(inst_libdir
)/libm.so
135 $(inst_libdir
)/libm.so
: $(common-objpfx
)format.lds \
139 (echo
'/* GNU ld script'; echo
'*/';\
141 echo
'GROUP ( $(slibdir)/libm.so$(libm.so-version) ' \
142 'AS_NEEDED ( $(libdir)/libmvec_nonshared.a $(slibdir)/libmvec.so$(libmvec.so-version) ) )' \
147 # Rules for the test suite.
148 tests
= test-matherr test-fenv atest-exp atest-sincos atest-exp2 basic-test \
149 test-misc test-fpucw test-fpucw-ieee tst-definitions test-tgmath \
150 test-tgmath-ret bug-nextafter bug-nexttoward bug-tgmath1 \
151 test-tgmath-int test-tgmath2 test-powl tst-CMPLX tst-CMPLX2 test-snan \
152 test-fenv-tls test-fenv-preserve test-fenv-return test-fenvinline \
153 test-nearbyint-except test-fenv-clear test-signgam-finite \
154 test-signgam-finite-c99 test-signgam-finite-c11 \
155 test-nearbyint-except-2 test-signgam-uchar test-signgam-uchar-init \
156 test-signgam-uint test-signgam-uint-init test-signgam-ullong \
157 test-signgam-ullong-init test-nan-overflow test-nan-payload \
158 test-fexcept test-fexcept-traps test-fesetexcept \
159 test-fesetexcept-traps test-fetestexceptflag test-femode \
160 test-femode-traps test-iszero-excess-precision \
161 test-iseqsig-excess-precision test-flt-eval-method \
162 test-fp-ilogb-constants
$(tests-static
)
163 tests-static
= test-fpucw-static test-fpucw-ieee-static \
164 test-signgam-uchar-static test-signgam-uchar-init-static \
165 test-signgam-uint-static test-signgam-uint-init-static \
166 test-signgam-ullong-static test-signgam-ullong-init-static
169 tests
+= test-math-isinff test-math-iszero
173 libm-vec-tests
= $(addprefix test-
,$(libmvec-tests
))
175 libm-tests
= $(foreach t
,$(types
),test-
$(t
) test-
$(t
)-finite test-i
$(t
)) \
178 libm-tests.o
= $(addsuffix .o
,$(libm-tests
))
180 tests
+= $(libm-tests
)
181 libm-vec-test-wrappers
= $(addsuffix -wrappers
, $(libm-vec-tests
))
182 test-extras
+= $(libm-vec-test-wrappers
)
183 extra-test-objs
+= $(addsuffix .o
, $(libm-vec-test-wrappers
))
184 libm-tests-generated
= libm-test-ulps.h libm-have-vector-test.h libm-test.c
185 generated
+= $(libm-tests-generated
) libm-test.stmp
187 # This is needed for dependencies
188 before-compile
+= $(objpfx
)libm-test.c
190 ulps-file
= $(firstword $(wildcard $(sysdirs
:%=%/libm-test-ulps
)))
192 $(addprefix $(objpfx
), $(libm-tests-generated
)): $(objpfx
)libm-test.stmp
194 $(objpfx
)libm-test.stmp
: $(ulps-file
) libm-test.inc gen-libm-test.pl \
195 gen-libm-have-vector-test.sh auto-libm-test-out
196 $(make-target-directory
)
197 $(PERL
) gen-libm-test.pl
-u
$< -o
"$(objpfx)"
198 $(SHELL
) gen-libm-have-vector-test.sh
> $(objpfx
)libm-have-vector-test.h
202 libm-test-fast-math-cflags
= -fno-builtin
-D__FAST_MATH__
-DTEST_FAST_MATH
203 libm-test-vec-cflags
= $(libm-test-fast-math-cflags
) -fno-inline \
204 -ffloat-store
-D_OPENMP
=201307 -Wno-unknown-pragmas
206 CFLAGS-test-double-vlen2.c
= $(libm-test-vec-cflags
)
208 CFLAGS-test-double-vlen4.c
= $(libm-test-vec-cflags
)
209 CFLAGS-test-double-vlen4-wrappers.c
= $(double-vlen4-arch-ext-cflags
)
211 CFLAGS-test-double-vlen8.c
= $(libm-test-vec-cflags
)
212 CFLAGS-test-double-vlen8-wrappers.c
= $(double-vlen8-arch-ext-cflags
)
214 CFLAGS-test-float-vlen4.c
= $(libm-test-vec-cflags
)
216 CFLAGS-test-float-vlen8.c
= $(libm-test-vec-cflags
)
217 CFLAGS-test-float-vlen8-wrappers.c
= $(float-vlen8-arch-ext-cflags
)
219 CFLAGS-test-float-vlen16.c
= $(libm-test-vec-cflags
)
220 CFLAGS-test-float-vlen16-wrappers.c
= $(float-vlen16-arch-ext-cflags
)
222 # The no-inline tests use -fsignaling-nans, and thereby use the
223 # versions of classification macros that support sNaNs. The inline
224 # function tests use the versions of classification macros that may
225 # raise spurious exceptions for sNaNs, but also do not test for
226 # exceptions. Thus both versions of the classification macros are
228 libm-test-no-inline-cflags
= -fno-inline
-ffloat-store
-fno-builtin \
230 libm-test-finite-cflags
= $(libm-test-no-inline-cflags
) \
231 -U__FINITE_MATH_ONLY__
-D__FINITE_MATH_ONLY__
=1
232 CFLAGS-test-float.c
= $(libm-test-no-inline-cflags
)
233 CFLAGS-test-float-finite.c
= $(libm-test-finite-cflags
)
234 CFLAGS-test-double.c
= $(libm-test-no-inline-cflags
)
235 CFLAGS-test-double-finite.c
= $(libm-test-finite-cflags
)
236 CFLAGS-test-ldouble.c
= $(libm-test-no-inline-cflags
)
237 CFLAGS-test-ldouble-finite.c
= $(libm-test-finite-cflags
)
238 CFLAGS-test-tgmath.c
= -fno-builtin
239 # The following testcase uses very long lines (>3 million), so it may take a
240 # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
241 # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54402
242 CFLAGS-test-tgmath2.c
= -fno-builtin
243 CFLAGS-test-tgmath-ret.c
= -fno-builtin
244 CFLAGS-test-powl.c
= -fno-builtin
246 CFLAGS-test-snan.c
= -fsignaling-nans
247 CPPFLAGS-test-ifloat.c
= -U__LIBC_INTERNAL_MATH_INLINES \
248 $(libm-test-fast-math-cflags
)
249 CPPFLAGS-test-idouble.c
= -U__LIBC_INTERNAL_MATH_INLINES \
250 $(libm-test-fast-math-cflags
)
251 CPPFLAGS-test-ildouble.c
= -U__LIBC_INTERNAL_MATH_INLINES \
252 $(libm-test-fast-math-cflags
)
254 CFLAGS-test-signgam-finite.c
= -ffinite-math-only
255 CFLAGS-test-signgam-finite-c99.c
= -ffinite-math-only
-std
=c99
256 CFLAGS-test-signgam-finite-c11.c
= -ffinite-math-only
-std
=c11
257 CFLAGS-test-signgam-uchar.c
= -std
=c99
258 CFLAGS-test-signgam-uchar-init.c
= -std
=c99
259 CFLAGS-test-signgam-uchar-static.c
= -std
=c99
260 CFLAGS-test-signgam-uchar-init-static.c
= -std
=c99
261 CFLAGS-test-signgam-uint.c
= -std
=c99
262 CFLAGS-test-signgam-uint-init.c
= -std
=c99
263 CFLAGS-test-signgam-uint-static.c
= -std
=c99
264 CFLAGS-test-signgam-uint-init-static.c
= -std
=c99
265 CFLAGS-test-signgam-ullong.c
= -std
=c99
266 CFLAGS-test-signgam-ullong-init.c
= -std
=c99
267 CFLAGS-test-signgam-ullong-static.c
= -std
=c99
268 CFLAGS-test-signgam-ullong-init-static.c
= -std
=c99
270 CFLAGS-test-math-isinff.
cc = -std
=gnu
++11
271 CFLAGS-test-math-iszero.
cc = -std
=gnu
++11
273 CFLAGS-test-iszero-excess-precision.c
= -fexcess-precision
=standard
274 CFLAGS-test-iseqsig-excess-precision.c
= -fexcess-precision
=standard
275 CFLAGS-test-flt-eval-method.c
= -fexcess-precision
=standard
277 # The -lieee module sets the _LIB_VERSION_ switch to IEEE mode
278 # for error handling in the -lm functions.
279 install-lib
+= libieee.a
280 non-lib.a
+= libieee.a
281 extra-objs
+= libieee.a ieee-math.o
285 gen-all-calls
= $(gen-libm-calls
) $(gen-calls
)
287 generated
+= $(addsuffix .c
,$(call type-foreach
,$(gen-all-calls
))) \
288 gen-libm-templates.stmp
290 # Create wrappers in the math build directory.
291 $(objpfx
)gen-libm-templates.stmp
: Makefile
292 $(make-target-directory
)
293 for gcall in
$(gen-all-calls
); do \
294 func
=$${gcall
%F
*}$${gcall
#*F}; \
295 for type in
$(foreach t
,$(types
),$(t
)__
$(type-
$(t
)-suffix)); do \
298 file
=$(objpfx
)$${gcall
%F
*}$${suff}$${gcall
#*F}.c; \
300 echo
"#include <math-type-macros-$${type}.h>"; \
301 echo
"#include <$${func}_template.c>"; \
307 # Add dependency to ensure the generator runs prior.
308 $(foreach t
, $(call type-foreach
, $(gen-all-calls
)), \
309 $(objpfx
)$(t
).c
): $(objpfx
)gen-libm-templates.stmp
312 # This must come after the inclusion of sysdeps Makefiles via Rules.
313 $(addprefix $(objpfx
), $(libm-tests.o
)): $(objpfx
)libm-test.stmp
315 # Run the math programs to automatically generate ULPs files.
318 run-regen-ulps
= $(test-wrapper-env
) \
320 $($*-ENV
) $(rtld-prefix
) $${run}
322 regen-ulps
: $(addprefix $(objpfx
),$(libm-tests
))
323 rm -f
$(objpfx
)ULPs
; rm -f
$(objpfx
)NewUlps
; \
324 cp
$(ulps-file
) $(objpfx
)libm-test-ulps
; \
326 echo
"Regenerating ULPs for $${run}"; \
327 $(run-regen-ulps
) -u
-o
$(objpfx
); \
328 cat
$(objpfx
)ULPs
>> $(objpfx
)libm-test-ulps
; \
331 $(PERL
) gen-libm-test.pl
-o
$(objpfx
) -n
-u
$(objpfx
)libm-test-ulps
; \
332 echo
"Automatic regeneration of ULPs complete."; \
333 echo
"Difference between the current baseline and the new baseline is:";\
334 diff
-urN
$(ulps-file
) $(objpfx
)NewUlps
; \
335 echo
"Copy $(objpfx)NewUlps to $(ulps-file) (relative to source)."
338 @echo
"Automatic regeneration of ULPs requires perl."; \
342 # The generated sysd-rules file defines rules like this for sources
343 # coming from sysdeps/ directories. These rules find the generic sources.
344 define o-iterator-doit
345 $(objpfx
)m_
%$o: s_
%.c
$(before-compile
); $$(compile-command.c
)
347 object-suffixes-left
:= $(all-object-suffixes
)
348 include $(o-iterator
)
350 # Likewise, for those generated files shared with libc.
351 define o-iterator-doit
352 $(objpfx
)m_
%$o: $(objpfx
)s_
%.c
$(before-compile
); $$(compile-command.c
)
354 object-suffixes-left
:= $(all-object-suffixes
)
355 include $(o-iterator
)
357 # This file defines the default _LIB_VERSION variable that controls
358 # the error return conventions for the math functions.
359 CPPFLAGS-s_lib_version.c
:= -D_POSIX_MODE
361 # We don't want the fdlibm code to use the inline math functions,
362 # only the fdlibm code.
363 math-CPPFLAGS
+= -D__NO_MATH_INLINES
-D__LIBC_INTERNAL_MATH_INLINES
365 ifneq ($(long-double-fcts
),yes
)
366 # The `double' and `long double' types are the same on this machine.
367 # We won't compile the `long double' code at all. Tell the `double' code
368 # to define aliases for the `FUNCl' names. To avoid type conflicts in
369 # defining those aliases, tell <math.h> to declare the `FUNCl' names with
370 # `double' instead of `long double'.
371 math-CPPFLAGS
+= -DNO_LONG_DOUBLE
-D_Mlong_double_
=double
374 # These files quiet sNaNs in a way that is optimized away without
376 CFLAGS-s_modf.c
+= -fsignaling-nans
377 CFLAGS-s_modff.c
+= -fsignaling-nans
378 CFLAGS-s_modfl.c
+= -fsignaling-nans
380 # The -lieee library is actually an object file.
381 # The module just defines the _LIB_VERSION_ variable.
382 # It's not a library to make sure it is linked in instead of s_lib_version.o.
383 $(objpfx
)libieee.a
: $(objpfx
)ieee-math.o
385 $(patsubst %/,cd
% &&,$(objpfx
)) \
388 $(addprefix $(objpfx
),\
389 $(filter-out $(tests-static
) $(libm-vec-tests
),$(tests
))): $(libm
)
390 $(addprefix $(objpfx
),$(tests-static
)): $(objpfx
)libm.a
391 $(addprefix $(objpfx
), $(libm-vec-tests
)): $(objpfx
)%: $(objpfx
)%-wrappers.o \
394 gmp-objs
= $(patsubst %,$(common-objpfx
)stdlib
/%.o
,\
395 add_n sub_n cmp addmul_1 mul_1 mul_n divmod_1 \
396 lshift rshift mp_clz_tab udiv_qrnnd inlines \
397 $(gmp-sysdep_routines
))
398 $(objpfx
)atest-exp
: $(gmp-objs
)
399 $(objpfx
)atest-sincos
: $(gmp-objs
)
400 $(objpfx
)atest-exp2
: $(gmp-objs
)
401 $(objpfx
)test-fenv-tls
: $(shared-thread-library
)