math/Makefile

   1 # Copyright (C) 1996-2024 Free Software Foundation, Inc.
   2 # This file is part of the GNU C Library.
   3
   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.
   8
   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.
  13
  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/>.
  17
  18 # Makefile for the math library.
  19
  20 subdir          := math
  21
  22 include ../Makeconfig
  23
  24 # Installed header files.
  25 headers := \
  26   math.h \
  27   bits/mathcalls.h \
  28   fpu_control.h \
  29   complex.h \
  30   bits/cmathcalls.h \
  31   fenv.h \
  32   bits/fenv.h \
  33   bits/mathdef.h \
  34   tgmath.h \
  35   bits/math-vector.h \
  36   finclude/math-vector-fortran.h \
  37   bits/libm-simd-decl-stubs.h \
  38   bits/iscanonical.h \
  39   bits/flt-eval-method.h \
  40   bits/fp-fast.h \
  41   bits/fp-logb.h \
  42   bits/long-double.h \
  43   bits/mathcalls-helper-functions.h \
  44   bits/floatn.h \
  45   bits/floatn-common.h \
  46   bits/mathcalls-narrow.h
  47   # headers
  48
  49 # FPU support code.
  50 aux := \
  51   fpu_control \
  52   setfpucw \
  53   # aux
  54
  55 # Build the -lm library.
  56
  57 extra-libs      := libm
  58 extra-libs-others = $(extra-libs)
  59
  60 libm-support = \
  61   fclrexcpt \
  62   fedisblxcpt \
  63   feenablxcpt \
  64   fegetenv \
  65   fegetexcept \
  66   fegetmode \
  67   fegetround \
  68   feholdexcpt \
  69   fesetenv \
  70   fesetexcept \
  71   fesetmode\
  72   fesetround \
  73   fetestexceptflag \
  74   feupdateenv \
  75   fgetexcptflg \
  76   fraiseexcpt \
  77   fsetexcptflg \
  78   ftestexcept \
  79   s_lib_version \
  80   s_matherr \
  81   s_signgam \
  82   # libm-support
  83
  84 # Wrappers for these functions generated per type using a file named
  85 # <func>_template.c and the appropriate math-type-macros-<TYPE>.h.
  86 gen-libm-calls = \
  87   cabsF \
  88   cargF \
  89   cimagF \
  90   conjF \
  91   crealF \
  92   e_exp2F \
  93   e_scalbF \
  94   k_casinhF \
  95   k_casinhF \
  96   s_cacosF  \
  97   s_cacoshF \
  98   s_canonicalizeF \
  99   s_casinF \
 100   s_casinhF \
 101   s_catanF \
 102   s_catanhF \
 103   s_ccosF \
 104   s_ccoshF \
 105   s_cexpF \
 106   s_clog10F \
 107   s_clogF \
 108   s_cpowF \
 109   s_cprojF \
 110   s_csinF \
 111   s_csinhF \
 112   s_csinhF \
 113   s_csqrtF \
 114   s_ctanF \
 115   s_ctanhF \
 116   s_exp10m1F \
 117   s_exp2m1F \
 118   s_fdimF \
 119   s_fmaxF \
 120   s_fmaximumF \
 121   s_fmaximum_magF \
 122   s_fmaximum_mag_numF \
 123   s_fmaximum_numF \
 124   s_fmaxmagF \
 125   s_fminF \
 126   s_fminimumF \
 127   s_fminimum_magF \
 128   s_fminimum_mag_numF \
 129   s_fminimum_numF \
 130   s_fminmagF \
 131   s_iseqsigF \
 132   s_log10p1F \
 133   s_log2p1F \
 134   s_nanF \
 135   s_nextdownF \
 136   s_significandF \
 137   w_acosF \
 138   w_acoshF \
 139   w_asinF \
 140   w_atan2F \
 141   w_atanhF \
 142   w_coshF \
 143   w_exp10F \
 144   w_exp2F \
 145   w_expF \
 146   w_fmodF \
 147   w_hypotF \
 148   w_ilogbF \
 149   w_j0F \
 150   w_j1F \
 151   w_jnF \
 152   w_lgammaF \
 153   w_lgammaF_r \
 154   w_llogbF \
 155   w_log10F \
 156   w_log1pF \
 157   w_log2F \
 158   w_logF  \
 159   w_powF \
 160   w_remainderF \
 161   w_scalbF \
 162   w_scalblnF \
 163   w_sinhF \
 164   w_sqrtF \
 165   w_tgammaF \
 166   # gen-libm-calls
 167
 168 libm-calls = \
 169   $(calls:s_%=m_%) \
 170   $(gen-libm-calls) \
 171   e_acosF \
 172   e_acoshF \
 173   e_asinF \
 174   e_atan2F \
 175   e_atanhF \
 176   e_coshF \
 177   e_exp10F \
 178   e_expF \
 179   e_fmodF \
 180   e_gammaF_r \
 181   e_hypotF \
 182   e_ilogbF \
 183   e_j0F \
 184   e_j1F \
 185   e_jnF \
 186   e_lgammaF_r \
 187   e_log10F \
 188   e_log2F \
 189   e_logF \
 190   e_powF \
 191   e_remainderF \
 192   e_sinhF \
 193   e_sqrtF \
 194   gamma_productF \
 195   k_tanF \
 196   lgamma_negF \
 197   lgamma_productF \
 198   s_asinhF \
 199   s_atanF \
 200   s_cbrtF \
 201   s_ceilF \
 202   s_cosF \
 203   s_erfF \
 204   s_expm1F \
 205   s_fabsF \
 206   s_floorF \
 207   s_fmaF \
 208   s_fpclassifyF \
 209   s_fromfpF \
 210   s_fromfpxF \
 211   s_getpayloadF \
 212   s_issignalingF \
 213   s_llrintF \
 214   s_llroundF \
 215   s_log1pF \
 216   s_logbF \
 217   s_lrintF \
 218   s_lroundF \
 219   s_nearbyintF \
 220   s_nextafterF \
 221   s_nexttowardF \
 222   s_nextupF \
 223   s_remquoF \
 224   s_rintF \
 225   s_roundF \
 226   s_roundevenF \
 227   s_scalblnF \
 228   s_setpayloadF \
 229   s_setpayloadsigF \
 230   s_sinF \
 231   s_sincosF \
 232   s_tanF \
 233   s_tanhF \
 234   s_totalorderF \
 235   s_totalordermagF \
 236   s_truncF \
 237   s_ufromfpF \
 238   s_ufromfpxF \
 239   x2y2m1F \
 240   # libm-calls
 241
 242 libm-compat-calls = \
 243   k_standardF \
 244   w_acosF_compat \
 245   w_acoshF_compat \
 246   w_asinF_compat \
 247   w_atan2F_compat \
 248   w_atanhF_compat \
 249   w_coshF_compat \
 250   w_exp10F_compat \
 251   w_exp2F_compat \
 252   w_expF_compat \
 253   w_fmodF_compat \
 254   w_hypotF_compat \
 255   w_j0F_compat \
 256   w_j1F_compat\
 257   w_jnF_compat \
 258   w_lgammaF_compat2 \
 259   w_lgammaF_r_compat \
 260   w_lgamma_compatF \
 261   w_log10F_compat \
 262   w_log2F_compat \
 263   w_logF_compat \
 264   w_powF_compat \
 265   w_remainderF_compat \
 266   w_scalbF_compat \
 267   w_sinhF_compat \
 268   w_sqrtF_compat \
 269   w_tgammaF_compat \
 270   # libm-compat-calls
 271
 272 libm-narrow-fns = \
 273   add \
 274   div \
 275   fma \
 276   mul \
 277   sqrt \
 278   sub \
 279   # libm-narrow-fns
 280 libm-narrow-types-basic = \
 281   s_f32xFf64 \
 282   s_fF \
 283   # libm-narrow-types-basic
 284 libm-narrow-types-ldouble-yes = \
 285   s_dFl \
 286   s_fFl \
 287   # libm-narrow-types-ldouble-yes
 288 libm-narrow-types-float128-yes = \
 289   s_f32Ff128 \
 290   s_f64Ff128 \
 291   s_f64xFf128 \
 292   # libm-narrow-types-float128-yes
 293 libm-narrow-types-float128-alias-yes = \
 294   s_f64xFf128 \
 295   # libm-narrow-types-float128-alias-yes
 296 libm-narrow-types = \
 297   $(libm-narrow-types-basic) \
 298   $(libm-narrow-types-float128-$(float128-fcts)) \
 299   $(libm-narrow-types-float128-alias-$(float128-alias-fcts)) \
 300   $(libm-narrow-types-ldouble-$(long-double-fcts)) \
 301   # libm-narrow-types
 302
 303 # Type specific routine support.
 304 #
 305 # The following three variables control what is included for each type:
 306 #
 307 # type-floatN-suffix = The suffix of the type
 308 # type-floatN-routines = Type specific support objects
 309 # type-floatN-yes = If the type is supported, evaluates to floatN
 310 #
 311 # Finally, note that types is an intentionally recursive variable.
 312 # We only know the full set of supported types for the target machine
 313 # after the Rules makefile has been parsed.
 314 types-basic = \
 315   $(type-ldouble-$(long-double-fcts)) \
 316   double \
 317   float \
 318   # types-basic
 319
 320 # Like types, but includes types whose functions alias those for
 321 # another type.
 322 test-types-basic = \
 323   double \
 324   float \
 325   ldouble \
 326   # test-types-basic
 327
 328 # long double support
 329 type-ldouble-suffix := l
 330 type-ldouble-routines := \
 331   e_rem_pio2l \
 332   k_cosl \
 333   k_sincosl \
 334   k_sinl \
 335   s_iscanonicall \
 336   t_sincosl \
 337   # type-ldouble-routines
 338 type-ldouble-yes := ldouble
 339
 340 # double support
 341 type-double-suffix :=
 342 type-double-routines := \
 343   branred \
 344   e_exp_data \
 345   e_log2_data \
 346   e_log_data \
 347   e_pow_log_data \
 348   k_rem_pio2 \
 349   math_err \
 350   sincostab \
 351   # type-double-routines
 352
 353 # float support
 354 type-float-suffix := f
 355 type-float-routines := \
 356   e_exp2f_data \
 357   e_log2f_data \
 358   e_logf_data \
 359   e_powf_log2_data \
 360   math_errf \
 361   s_sincosf_data \
 362   # type-float-routines
 363
 364 # _Float128 support
 365 type-float128-suffix := f128
 366 type-float128-routines := \
 367   e_rem_pio2f128 \
 368   k_cosf128 \
 369   k_sincosf128 \
 370   k_sinf128 \
 371   t_sincosf128 \
 372   # type-float128-routines
 373 type-float128-yes := float128
 374
 375 # _Float64x may be supported, only as an alias type.
 376 type-float64x-yes := float64x
 377
 378 # IBM long double support in additional to IEEE 128 long double support
 379 type-ibm128-suffix := l
 380 type-ibm128-yes := ibm128
 381
 382 types = \
 383   $(type-float128-$(float128-fcts)) \
 384   $(types-basic) \
 385   # types
 386 test-types = \
 387   $(test-types-basic) \
 388   $(type-float128-$(float128-alias-fcts)) \
 389   $(type-float128-$(float128-fcts)) \
 390   $(type-float64x-$(float64x-alias-fcts)) \
 391   $(type-ibm128-$(ibm128-fcts)) \
 392   float32 \
 393   float32x \
 394   float64 \
 395   # test-types
 396
 397 # Pairs of types for which narrowing functions should be tested (this
 398 # variable has more entries than libm-narrow-types because it includes
 399 # pairs for which the functions sometimes or always alias functions
 400 # for other types). This definition embeds the assumption that if
 401 # _Float64x is supported, so is _Float128, and vice versa (they may or
 402 # may not have the same format).
 403 test-type-pairs = \
 404   $(test-type-pairs-f64xf128-$(float128-alias-fcts)) \
 405   $(test-type-pairs-f64xf128-$(float128-fcts)) \
 406   double-ldouble \
 407   float-double \
 408   float-ldouble \
 409   float32-float32x \
 410   float32-float64 \
 411   float32x-float64 \
 412   # test-type-pairs
 413 test-type-pairs-f64xf128-yes = \
 414   float32-float128 \
 415   float32-float64x \
 416   float32x-float128 \
 417   float32x-float64x \
 418   float64-float128 \
 419   float64-float64x \
 420   float64x-float128 \
 421   # test-type-pairs-f64xf128-yes
 422
 423 # For each of the basic types (float, double, long double), replace the
 424 # occurrences of 'F' in arg 1 with the appropriate suffix for the type.
 425 type-basic-foreach = $(foreach t, $(types-basic), \
 426                        $(subst F,$(type-$(t)-suffix),$(1)))
 427
 428 # Apply suffix to each type in arg 1
 429 type-foreach = $(foreach t,$(types),$(subst F,$(type-$(t)-suffix),$(1)))
 430
 431 libm-routines = $(strip $(libm-support)                                 \
 432                         $(call type-basic-foreach,                      \
 433                                $(libm-compat-calls))                    \
 434                         $(call type-foreach, $(libm-calls))             \
 435                         $(foreach t, $(types), $(type-$(t)-routines)))  \
 436                         $(foreach f,$(libm-narrow-fns),                 \
 437                                     $(subst F,$(f),$(libm-narrow-types)))
 438
 439 # These functions are in libc instead of libm because __printf_fp
 440 # calls them, so any program using printf will need them linked in,
 441 # and we don't want to have to link every program with -lm.
 442 # In libm-calls (above), list m_foo in place of s_foo for any
 443 # routine that should be compiled separately for its libc and libm versions.
 444 calls = \
 445   $(gen-calls) \
 446   s_copysignF \
 447   s_finiteF \
 448   s_frexpF \
 449   s_isinfF \
 450   s_isnanF \
 451   s_modfF \
 452   s_scalbnF \
 453   s_signbitF \
 454   # calls
 455 gen-calls = s_ldexpF
 456 generated += $(foreach s,.c .S,$(call type-foreach, $(calls:s_%=m_%$(s))))
 457 routines = $(call type-foreach, $(calls))
 458 # The $(calls) that are shared between libm and libc are not included in static
 459 # libm so the symbols end up in exactly one place.
 460 libm-shared-only-routines = $(call type-foreach, $(calls:s_%=m_%))
 461
 462 ifeq ($(build-mathvec),yes)
 463 # We need to install libm.so and libm.a as linker scripts
 464 # for transparent use of vector math library.
 465 install-lib-ldscripts := \
 466   libm.a \
 467   libm.so \
 468   # install-lib-ldscripts
 469 install-others = \
 470   $(inst_libdir)/libm.a \
 471   $(inst_libdir)/libm.so \
 472   # install-others
 473 $(inst_libdir)/libm.so: $(common-objpfx)format.lds \
 474                         $(libm) \
 475                         $(libmvec) \
 476                         $(+force)
 477         (echo '/* GNU ld script'; echo '*/';\
 478          cat $<; \
 479          echo 'GROUP ( $(slibdir)/libm.so$(libm.so-version) ' \
 480               'AS_NEEDED ( $(slibdir)/libmvec.so$(libmvec.so-version) ) )' \
 481         ) > $@.new
 482         mv -f $@.new $@
 483
 484 $(inst_libdir)/libm-$(version).a: $(objpfx)libm.a \
 485                                   $(+force)
 486         $(do-install)
 487
 488 $(inst_libdir)/libm.a: $(common-objpfx)format.lds \
 489                        $(inst_libdir)/libm-$(version).a \
 490                        $(objpfx)../mathvec/libmvec.a \
 491                        $(+force)
 492         (echo '/* GNU ld script'; echo '*/';\
 493          cat $<; \
 494          echo 'GROUP ( $(libdir)/libm-$(version).a $(libdir)/libmvec.a )' \
 495         ) > $@.new
 496         mv -f $@.new $@
 497 endif
 498
 499 # Rules for the test suite.
 500 tests = \
 501   $(tests-static) \
 502   bug-nextafter \
 503   bug-nexttoward \
 504   bug-tgmath1 \
 505   test-ceil-except-2 \
 506   test-femode \
 507   test-femode-traps \
 508   test-fenv basic-test \
 509   test-fenv-clear \
 510   test-fenv-preserve \
 511   test-fenv-return \
 512   test-fenv-tls \
 513   test-fesetexcept \
 514   test-fesetexcept-traps \
 515   test-fetestexceptflag \
 516   test-fexcept \
 517   test-fexcept-traps \
 518   test-floor-except-2 \
 519   test-flt-eval-method \
 520   test-fp-ilogb-constants \
 521   test-fp-llogb-constants \
 522   test-fpucw \
 523   test-fpucw-ieee \
 524   test-iseqsig-excess-precision \
 525   test-iszero-excess-precision \
 526   test-matherr-3 \
 527   test-misc \
 528   test-nan-const \
 529   test-nan-overflow \
 530   test-nan-payload \
 531   test-narrow-macros \
 532   test-nearbyint-except \
 533   test-nearbyint-except-2 \
 534   test-powl \
 535   test-signgam-uchar \
 536   test-signgam-uchar-init \
 537   test-signgam-uint \
 538   test-signgam-uint-init \
 539   test-signgam-ullong \
 540   test-signgam-ullong-init \
 541   test-snan \
 542   test-tgmath \
 543   test-tgmath-int \
 544   test-tgmath-ret \
 545   test-tgmath2 \
 546   test-trunc-except-2 \
 547   tst-CMPLX \
 548   tst-CMPLX2 \
 549   tst-definitions \
 550   # tests
 551 ifneq ($(config-cflags-signaling-nans),)
 552 tests += \
 553   test-fe-snans-always-signal \
 554   # tests
 555 endif
 556 tests-static = \
 557   test-fpucw-ieee-static \
 558   test-fpucw-static \
 559   test-signgam-uchar-init-static \
 560   test-signgam-uchar-static \
 561   test-signgam-uint-init-static \
 562   test-signgam-uint-static \
 563   test-signgam-ullong-init-static \
 564   test-signgam-ullong-static \
 565   # tests-static
 566
 567 # The tested symbols matherr, _LIB_VERSION have been removed in glibc 2.27.
 568 ifeq ($(have-GLIBC_2.26)$(build-shared),yesyes)
 569 tests += \
 570   test-matherr \
 571   test-matherr-2 \
 572   # tests
 573 tests-2.0 += \
 574   test-matherr-2 \
 575   # tests-2.0
 576 endif
 577
 578 # These tests use internal (unexported) GMP functions and are linked
 579 # statically to obtain access to these functions.
 580 tests-static += \
 581   atest-exp \
 582   atest-exp2 \
 583   atest-sincos \
 584   # tests-static
 585
 586 ifneq (,$(CXX))
 587 tests += \
 588   test-math-cxx11 \
 589   test-math-iscanonical \
 590   test-math-iseqsig \
 591   test-math-isinff \
 592   test-math-issignaling \
 593   test-math-iszero \
 594   # tests
 595 endif
 596
 597 libm-vec-tests = $(addprefix test-,$(libmvec-tests))
 598 libm-test-support = $(foreach t,$(test-types),libm-test-support-$(t))
 599 libm-test-support-static = $(foreach t,$(test-types),libm-test-support-$(t)-static)
 600 test-extras += $(libm-test-support) $(libm-test-support-static)
 601 extra-test-objs += $(addsuffix .o, $(libm-test-support)) \
 602                    $(addsuffix .o, $(libm-test-support-static))
 603 libm-vec-test-wrappers = $(addsuffix -wrappers, $(libm-vec-tests))
 604 test-extras += $(libm-vec-test-wrappers)
 605 extra-test-objs += $(addsuffix .o, $(libm-vec-test-wrappers))
 606
 607 ulps-file = $(firstword $(wildcard $(sysdirs:%=%/libm-test-ulps)))
 608
 609 $(objpfx)libm-test-ulps.h: $(ulps-file) gen-libm-test.py
 610         $(make-target-directory)
 611         $(PYTHON) gen-libm-test.py -u $< -H $@
 612
 613 libm-test-funcs-auto = \
 614   acos \
 615   acosh \
 616   asin \
 617   asinh \
 618   atan \
 619   atan2 \
 620   atanh \
 621   cabs \
 622   cacos \
 623   cacosh \
 624   carg \
 625   casin \
 626   casinh \
 627   catan \
 628   catanh \
 629   cbrt \
 630   ccos \
 631   ccosh \
 632   cexp \
 633   clog \
 634   clog10 \
 635   cos \
 636   cosh \
 637   cpow \
 638   csin \
 639   csinh \
 640   csqrt \
 641   ctan \
 642   ctanh \
 643   erf \
 644   erfc \
 645   exp \
 646   exp2 \
 647   exp10 \
 648   exp10m1 \
 649   exp2m1 \
 650   expm1 \
 651   fma \
 652   hypot \
 653   j0 \
 654   j1 \
 655   jn \
 656   lgamma \
 657   log \
 658   log2 \
 659   log10 \
 660   log10p1 \
 661   log1p \
 662   log2p1 \
 663   pow \
 664   sin \
 665   sincos \
 666   sinh \
 667   sqrt \
 668   tan \
 669   tanh \
 670   tgamma \
 671   y0 \
 672   y1 \
 673   yn \
 674   # libm-test-funcs-auto
 675 libm-test-funcs-noauto-base = \
 676   canonicalize \
 677   ceil \
 678   cimag \
 679   conj \
 680   copysign \
 681   cproj \
 682   creal \
 683   fabs \
 684   fdim \
 685   floor \
 686   fmax \
 687   fmaximum \
 688   fmaximum_mag \
 689   fmaximum_mag_num \
 690   fmaximum_num \
 691   fmaxmag \
 692   fmin \
 693   fminimum \
 694   fminimum_mag \
 695   fminimum_mag_num \
 696   fminimum_num \
 697   fminmag \
 698   fmod \
 699   fpclassify \
 700   frexp \
 701   fromfp \
 702   fromfpx \
 703   getpayload \
 704   ilogb \
 705   iscanonical \
 706   iseqsig \
 707   isfinite \
 708   isgreater \
 709   isgreaterequal \
 710   isinf \
 711   isless \
 712   islessequal \
 713   islessgreater \
 714   isnan \
 715   isnormal \
 716   issignaling \
 717   issubnormal \
 718   isunordered \
 719   iszero \
 720   llogb \
 721   llrint \
 722   llround \
 723   logb \
 724   lrint \
 725   lround \
 726   modf \
 727   nearbyint \
 728   nextafter \
 729   nextdown \
 730   nexttoward \
 731   nextup \
 732   remainder \
 733   remquo \
 734   rint \
 735   round \
 736   roundeven \
 737   scalb \
 738   scalbln \
 739   scalbn \
 740   setpayload \
 741   setpayloadsig \
 742   signbit \
 743   significand \
 744   totalorder \
 745   totalordermag \
 746   trunc \
 747   ufromfp \
 748   ufromfpx \
 749   # libm-test-funcs-noauto-base
 750 libm-test-funcs-noauto = \
 751   $(libm-test-funcs-noauto-base) \
 752   compat_totalorder \
 753   compat_totalordermag \
 754   # libm-test-funcs-noauto
 755 libm-test-funcs-compat = \
 756   compat_totalorder \
 757   compat_totalordermag \
 758   # libm-test-funcs-compat
 759 libm-test-funcs-narrow = \
 760   add \
 761   div \
 762   fma \
 763   mul \
 764   sqrt \
 765   sub \
 766   # libm-test-funcs-narrow
 767 libm-test-funcs-all = \
 768   $(libm-test-funcs-auto) \
 769   $(libm-test-funcs-noauto) \
 770   # libm-test-funcs-all
 771 libm-test-c-auto = $(foreach f,$(libm-test-funcs-auto),libm-test-$(f).c)
 772 libm-test-c-noauto = $(foreach f,$(libm-test-funcs-noauto),libm-test-$(f).c)
 773 libm-test-c-narrow = $(foreach f,$(libm-test-funcs-narrow),\
 774                                  libm-test-narrow-$(f).c)
 775 generated += \
 776   $(libm-test-c-auto) \
 777   $(libm-test-c-narrow) \
 778   $(libm-test-c-noauto) \
 779   libm-test-ulps.h \
 780   # generated
 781
 782 libm-tests-base-normal = $(foreach t,$(test-types),test-$(t))
 783 libm-tests-base-narrow = $(foreach t,$(test-type-pairs),test-$(t))
 784 libm-tests-base = $(libm-tests-base-normal) $(libm-vec-tests)
 785 libm-tests-normal = $(foreach t,$(libm-tests-base-normal),\
 786                                 $(foreach f,$(libm-test-funcs-all),\
 787                                             $(t)-$(f)))
 788 libm-tests-narrow = $(foreach t,$(libm-tests-base-narrow),\
 789                                 $(foreach f,$(libm-test-funcs-narrow),\
 790                                             $(t)-$(f)))
 791 libm-tests-vector = $(foreach t,$(libmvec-tests),\
 792                                 $(foreach f,$($(t)-funcs),test-$(t)-$(f)))
 793 libm-tests = $(libm-tests-normal) $(libm-tests-narrow) $(libm-tests-vector)
 794 libm-tests-compat = $(foreach t,$(libm-tests-base-normal) \
 795                                 $(libm-tests-base-finite),\
 796                                 $(foreach f,$(libm-test-funcs-compat),\
 797                                             $(t)-$(f)))
 798 libm-tests-for-type = $(foreach f,$(libm-test-funcs-all),\
 799                                   test-$(1)-$(f) test-i$(1)-$(f)) \
 800                       $(filter test-$(1)-%,$(libm-tests-vector) \
 801                                            $(libm-tests-narrow))
 802
 803 libm-tests.o = $(addsuffix .o,$(libm-tests))
 804
 805 tests += $(libm-tests)
 806 generated += $(addsuffix .c,$(libm-tests)) \
 807              $(foreach t,$(test-types),libm-test-support-$(t).c)
 808
 809 libm-test-c-auto-obj = $(addprefix $(objpfx),$(libm-test-c-auto))
 810 libm-test-c-noauto-obj = $(addprefix $(objpfx),$(libm-test-c-noauto))
 811 libm-test-c-narrow-obj = $(addprefix $(objpfx),$(libm-test-c-narrow))
 812
 813 $(libm-test-c-noauto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 814                                                   gen-libm-test.py
 815         $(make-target-directory)
 816         $(PYTHON) gen-libm-test.py -c $< -a /dev/null -C $@
 817
 818 $(libm-test-c-auto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 819                                                 gen-libm-test.py \
 820                                                 auto-libm-test-out%
 821         $(make-target-directory)
 822         $(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out$* -C $@
 823
 824 $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 825                                                   gen-libm-test.py \
 826                                                   auto-libm-test-out%
 827         $(make-target-directory)
 828         $(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out$* -C $@
 829
 830
 831 libm-test-funcs-auto-static = \
 832   $(libm-test-funcs-auto) \
 833   # libm-test-funcs-auto-static
 834 libm-test-funcs-noauto-static = \
 835   $(libm-test-funcs-noauto-base) \
 836   # libm-test-funcs-noauto-static
 837 libm-test-funcs-narrow-static = \
 838   $(libm-test-funcs-narrow) \
 839   # libm-test-funcs-narrow-static
 840 libm-test-funcs-all-static = $(libm-test-funcs-auto-static) $(libm-test-funcs-noauto-static)
 841
 842 libm-test-c-auto-static = $(foreach f,$(libm-test-funcs-auto-static),libm-test-$(f)-static.c)
 843 libm-test-c-noauto-static = $(foreach f,$(libm-test-funcs-noauto-static),libm-test-$(f)-static.c)
 844 libm-test-c-narrow-static = $(foreach f,$(libm-test-funcs-narrow-static),\
 845                                  libm-test-narrow-$(f)-static.c)
 846 generated += $(libm-test-c-auto-static) $(libm-test-c-noauto-static) $(libm-test-c-narrow-static)
 847
 848 libm-tests-normal-static = $(foreach t,$(libm-tests-base-normal),\
 849                                 $(foreach f,$(libm-test-funcs-all-static),\
 850                                             $(t)-$(f)-static))
 851 libm-tests-narrow-static = $(foreach t,$(libm-tests-base-narrow-static),\
 852                                 $(foreach f,$(libm-test-funcs-narrow-static),\
 853                                             $(t)-$(f)-static))
 854 libm-tests-vector-static = $(foreach t,$(libmvec-tests-static),\
 855                                 $(foreach f,$($(t)-funcs),test-$(t)-$(f)-static))
 856 libm-tests-static = $(libm-tests-normal-static) $(libm-tests-narrow-static) $(libm-tests-vector-static)
 857 libm-tests-for-type-static = $(foreach f,$(libm-test-funcs-all-static),\
 858                                          test-$(1)-$(f)-static test-i$(1)-$(f)-static) \
 859                              $(filter test-$(1)-%,$(libm-tests-vector-static) \
 860                                                   $(libm-tests-narrow-static))
 861
 862 libm-tests.o += $(addsuffix .o,$(libm-tests-static))
 863
 864 ifeq ($(build-math-static-tests),yes)
 865 tests-static += $(libm-tests-static)
 866 generated += $(addsuffix .c,$(libm-tests)) \
 867              $(foreach t,$(test-types),libm-test-support-$(t)-static.c)
 868 endif
 869
 870 libm-test-c-auto-obj-static = $(addprefix $(objpfx),$(libm-test-c-auto-static))
 871 libm-test-c-noauto-obj-static = $(addprefix $(objpfx),$(libm-test-c-noauto-static))
 872 libm-test-c-narrow-obj-static = $(addprefix $(objpfx),$(libm-test-c-narrow-static))
 873
 874 # Use the same input test definitions for both dynamic and static tests.
 875 .SECONDEXPANSION:
 876 $(libm-test-c-noauto-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
 877                                                          gen-libm-test.py
 878         $(make-target-directory)
 879         $(PYTHON) gen-libm-test.py -c $< -a /dev/null -C $@
 880
 881 .SECONDEXPANSION:
 882 $(libm-test-c-auto-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
 883                                                        gen-libm-test.py \
 884                                                        auto-libm-test-out$$(subst -static,,%)
 885         $(make-target-directory)
 886         $(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out`echo $* | sed 's/-static//'` -C $@
 887
 888 .SECONDEXPANSION:
 889 $(libm-test-c-narrow-obj-static): $(objpfx)libm-test%.c: libm-test$$(subst -static,,%).inc \
 890                                                          gen-libm-test.py \
 891                                                          auto-libm-test-out$$(subst -static,,%)
 892         $(make-target-directory)
 893         $(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out`echo $* | sed 's/-static//'` -C $@
 894
 895 # Tests for totalorder compat symbols reuse the table of tests as
 896 # processed by gen-libm-test.py, so add dependencies on the generated
 897 # .c files.
 898 $(foreach t,$(libm-tests-base),\
 899             $(objpfx)$(t)-compat_totalorder.o): $(objpfx)libm-test-totalorder.c
 900
 901 $(foreach t,$(libm-tests-base),\
 902             $(objpfx)$(t)-compat_totalordermag.o): $(objpfx)libm-test-totalordermag.c
 903
 904 # _Float128x omitted as not supported by gen-tgmath-tests.py.
 905 tgmath3-narrow-types = \
 906   d \
 907   f \
 908   f16 \
 909   f32 \
 910   f128 \
 911   f32x \
 912   f64 \
 913   f64x \
 914   # tgmath3-narrow-types
 915 tgmath3-narrow-macros = $(foreach t,$(tgmath3-narrow-types), \
 916                                     $(foreach f,$(libm-narrow-fns),$(t)$(f)))
 917 tgmath3-macros = \
 918   $(tgmath3-narrow-macros) \
 919   acos \
 920   acosh \
 921   asin \
 922   asinh \
 923   atan \
 924   atan2 \
 925   atanh \
 926   carg \
 927   cbrt \
 928   ceil \
 929   cimag \
 930   conj \
 931   copysign \
 932   cos \
 933   cosh \
 934   cproj \
 935   creal \
 936   erf \
 937   erfc \
 938   exp \
 939   exp10m1 \
 940   exp2 \
 941   exp10 \
 942   exp2m1 \
 943   expm1 \
 944   fabs \
 945   fdim \
 946   floor \
 947   fma \
 948   fmax \
 949   fmaximum \
 950   fmaximum_mag \
 951   fmaximum_mag_num \
 952   fmaximum_num \
 953   fmaxmag \
 954   fmin \
 955   fminimum \
 956   fminimum_mag \
 957   fminimum_mag_num \
 958   fminimum_num \
 959   fminmag \
 960   fmod \
 961   frexp \
 962   fromfp \
 963   fromfpx \
 964   hypot \
 965   ilogb \
 966   ldexp \
 967   lgamma \
 968   llogb \
 969   llrint \
 970   llround \
 971   log \
 972   log10 \
 973   log10p1 \
 974   log1p \
 975   log2 \
 976   log2p1 \
 977   logb \
 978   logp1 \
 979   lrint \
 980   lround \
 981   nearbyint \
 982   nextafter \
 983   nextdown \
 984   nexttoward \
 985   nextup \
 986   pow \
 987   remainder \
 988   remquo \
 989   rint \
 990   round \
 991   roundeven \
 992   scalb \
 993   scalbln \
 994   scalbn \
 995   sin \
 996   sinh \
 997   sqrt \
 998   tan \
 999   tanh \
1000   tgamma \
1001   trunc \
1002   ufromfp \
1003   ufromfpx \
1004   # tgmath3-macros
1005 tgmath3-macro-tests = $(addprefix test-tgmath3-,$(tgmath3-macros))
1006 tests += $(tgmath3-macro-tests)
1007 generated += $(addsuffix .c,$(tgmath3-macro-tests))
1008
1009 $(tgmath3-macro-tests:%=$(objpfx)%.o): CFLAGS += -fno-builtin
1010
1011 $(foreach m,$(tgmath3-macros),\
1012             $(objpfx)test-tgmath3-$(m).c): $(objpfx)test-tgmath3-%.c: \
1013                                            gen-tgmath-tests.py
1014         $(PYTHON) gen-tgmath-tests.py $* > $@
1015
1016 # Verify that the list of supported macros is in sync between the
1017 # Makefile and gen-tgmath-tests.py.
1018 tests-special += $(objpfx)test-tgmath3-macro-list.out
1019 $(objpfx)test-tgmath3-macro-list.out: gen-tgmath-tests.py
1020         $(PYTHON) $< check-list $(tgmath3-macros) > $@; \
1021         $(evaluate-test)
1022
1023 libm-test-fast-math-cflags = -fno-builtin -D__FAST_MATH__ -DTEST_FAST_MATH
1024 libm-test-vec-cflags = $(libm-test-fast-math-cflags) -fno-inline \
1025                        -ffloat-store -D_OPENMP=201307 -Wno-unknown-pragmas
1026
1027 CFLAGS-test-double-vlen4-wrappers.c += $(double-vlen4-arch-ext-cflags)
1028
1029 CFLAGS-test-double-vlen8-wrappers.c += $(double-vlen8-arch-ext-cflags)
1030
1031 CFLAGS-test-float-vlen8-wrappers.c += $(float-vlen8-arch-ext-cflags)
1032
1033 CFLAGS-test-float-vlen16-wrappers.c += $(float-vlen16-arch-ext-cflags)
1034
1035 # The no-inline tests use -fsignaling-nans, and thereby use the
1036 # versions of classification macros that support sNaNs.  The inline
1037 # function tests use the versions of classification macros that may
1038 # raise spurious exceptions for sNaNs, but also do not test for
1039 # exceptions.  Thus both versions of the classification macros are
1040 # validated.
1041 libm-test-no-inline-cflags = -fno-inline -ffloat-store -fno-builtin \
1042                              $(config-cflags-signaling-nans)
1043 CFLAGS-test-tgmath.c += -fno-builtin
1044 # The following testcase uses very long lines (>3 million), so it may take a
1045 # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
1046 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54402
1047 CFLAGS-test-tgmath2.c += -fno-builtin
1048 CFLAGS-test-tgmath-ret.c += -fno-builtin
1049 CFLAGS-test-powl.c += -fno-builtin
1050
1051 CFLAGS-test-snan.c += $(config-cflags-signaling-nans)
1052
1053 CFLAGS-test-signgam-uchar.c += -std=c99
1054 CFLAGS-test-signgam-uchar-init.c += -std=c99
1055 CFLAGS-test-signgam-uchar-static.c += -std=c99
1056 CFLAGS-test-signgam-uchar-init-static.c += -std=c99
1057 CFLAGS-test-signgam-uint.c += -std=c99
1058 CFLAGS-test-signgam-uint-init.c += -std=c99
1059 CFLAGS-test-signgam-uint-static.c += -std=c99
1060 CFLAGS-test-signgam-uint-init-static.c += -std=c99
1061 CFLAGS-test-signgam-ullong.c += -std=c99
1062 CFLAGS-test-signgam-ullong-init.c += -std=c99
1063 CFLAGS-test-signgam-ullong-static.c += -std=c99
1064 CFLAGS-test-signgam-ullong-init-static.c += -std=c99
1065
1066 CFLAGS-test-math-cxx11.cc += -std=c++11
1067
1068 CFLAGS-test-math-isinff.cc += -std=gnu++11
1069 CFLAGS-test-math-iszero.cc += -std=gnu++11
1070 CFLAGS-test-math-issignaling.cc += -std=gnu++11
1071 CFLAGS-test-math-iscanonical.cc += -std=gnu++11
1072
1073 CFLAGS-test-iszero-excess-precision.c += -fexcess-precision=standard
1074 CFLAGS-test-iseqsig-excess-precision.c += -fexcess-precision=standard
1075 CFLAGS-test-flt-eval-method.c += -fexcess-precision=standard
1076
1077 CFLAGS-test-fe-snans-always-signal.c += $(config-cflags-signaling-nans)
1078
1079 CFLAGS-test-nan-const.c += -fno-builtin
1080
1081 CFLAGS-test-ceil-except-2.c += -fno-builtin
1082 CFLAGS-test-floor-except-2.c += -fno-builtin
1083 CFLAGS-test-trunc-except-2.c += -fno-builtin
1084
1085 include ../Rules
1086
1087 gen-all-calls = $(gen-libm-calls) $(gen-calls)
1088
1089 generated += $(addsuffix .c,$(call type-foreach,$(gen-all-calls))) \
1090              gen-libm-templates.stmp
1091
1092 # Create wrappers in the math build directory.
1093 $(objpfx)gen-libm-templates.stmp: Makefile
1094         $(make-target-directory)
1095         for gcall in $(gen-all-calls); do                                 \
1096           func=$${gcall%F*}$${gcall#*F};                                  \
1097           for type in $(foreach t,$(types),$(t)__$(type-$(t)-suffix)); do \
1098             suff=$${type#*__};                                            \
1099             type=$${type%__*};                                            \
1100             file=$(objpfx)$${gcall%F*}$${suff}$${gcall#*F}.c;             \
1101             (                                                             \
1102               echo "#include <math-type-macros-$${type}.h>";              \
1103               echo "#include <$${func}_template.c>";                      \
1104             ) > $${file};                                                 \
1105           done;                                                           \
1106         done;                                                             \
1107         echo > $(@)
1108
1109 # Add dependency to ensure the generator runs prior.
1110 $(foreach t, $(call type-foreach, $(gen-all-calls)), \
1111              $(objpfx)$(t).c): $(objpfx)gen-libm-templates.stmp
1112
1113 # This must come after the inclusion of sysdeps Makefiles via Rules.
1114
1115 $(foreach t,$(libm-tests-normal),$(objpfx)$(t).c): $(objpfx)test-%.c:
1116         type_func=$*; \
1117         type=$${type_func%%-*}; \
1118         func=$${type_func#*-}; \
1119         ( \
1120           echo "#include <test-$$type.h>"; \
1121           echo "#include <test-math-exceptions.h>"; \
1122           echo "#include <test-math-errno.h>"; \
1123           echo "#include <test-math-scalar.h>"; \
1124           echo "#include <libm-test-$$func.c>"; \
1125         ) > $@
1126
1127 $(foreach t,$(libm-tests-normal-static),$(objpfx)$(t).c): $(objpfx)test-%.c:
1128         type_func=$*; \
1129         type=$${type_func%%-*}; \
1130         func=$${type_func#*-}; \
1131         ( \
1132           echo "#include <test-$$type.h>"; \
1133           echo "#include <test-math-exceptions.h>"; \
1134           echo "#include <test-math-errno.h>"; \
1135           echo "#include <test-math-scalar.h>"; \
1136           echo "#include <libm-test-$$func.c>"; \
1137         ) > $@
1138
1139 $(foreach t,$(libm-tests-narrow),$(objpfx)$(t).c): $(objpfx)test-%.c:
1140         type_pair_func=$*; \
1141         type_pair=$${type_pair_func%-*}; \
1142         func=$${type_pair_func##*-}; \
1143         ret_type=$${type_pair%%-*}; \
1144         arg_type=$${type_pair#*-}; \
1145         ( \
1146           echo "#include <test-$$ret_type.h>"; \
1147           echo "#include <test-arg-$$arg_type.h>"; \
1148           echo "#include <test-math-exceptions.h>"; \
1149           echo "#include <test-math-errno.h>"; \
1150           echo "#include <test-math-narrow.h>"; \
1151           echo "#include <libm-test-narrow-$$func.c>"; \
1152         ) > $@
1153
1154 $(foreach t,$(libm-tests-vector),$(objpfx)$(t).c): $(objpfx)test-%.c:
1155         type_func=$*; \
1156         type=$${type_func%-*}; \
1157         func=$${type_func##*-}; \
1158         func_args=$$(grep "ALL_RM_TEST ($$func," libm-test-$$func.inc \
1159                      | sed 's/.*RUN_TEST_LOOP_//;s/_.*//'); \
1160         ( \
1161           echo "#include <test-$$type.h>"; \
1162           echo "WRAPPER_DECL_$$func_args (WRAPPER_NAME (FUNC ($$func)))"; \
1163           echo "#include <libm-test-$$func.c>"; \
1164         ) > $@
1165
1166 $(foreach t,$(test-types),\
1167             $(objpfx)libm-test-support-$(t).c): $(objpfx)libm-test-support-%.c:
1168         ( \
1169           echo "#include <test-$*.h>"; \
1170           echo "#include <libm-test-support.c>"; \
1171         ) > $@
1172
1173 $(foreach t,$(test-types),\
1174             $(objpfx)libm-test-support-$(t)-static.c): $(objpfx)libm-test-support-%.c:
1175         ( \
1176           echo "#include <test-$*.h>"; \
1177           echo "#include <libm-test-support.c>"; \
1178         ) > $@
1179
1180 $(addprefix $(objpfx), $(libm-tests.o)): $(objpfx)libm-test-ulps.h
1181
1182 define o-iterator-doit
1183 $(foreach f,$(libm-test-funcs-all),\
1184             $(objpfx)$(o)-$(f).o): $(objpfx)$(o)%.o: $(objpfx)libm-test%.c
1185 endef
1186 object-suffixes-left := $(libm-tests-base)
1187 include $(o-iterator)
1188
1189 define o-iterator-doit
1190 $(foreach f,$(libm-test-funcs-all-static),\
1191             $(objpfx)$(o)-$(f)-static.o): $(objpfx)$(o)%.o: $(objpfx)libm-test%.c
1192 endef
1193 object-suffixes-left := $(libm-tests-base)
1194 include $(o-iterator)
1195
1196 define o-iterator-doit
1197 $(foreach f,$(libm-test-funcs-narrow),\
1198             $(objpfx)$(o)-$(f).o): $(objpfx)$(o)%.o: \
1199                                    $(objpfx)libm-test-narrow%.c
1200 endef
1201 object-suffixes-left := $(libm-tests-base-narrow)
1202 include $(o-iterator)
1203
1204 define o-iterator-doit
1205 $(foreach f,$(libm-test-funcs-all),\
1206             $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-no-inline-cflags)
1207 endef
1208 object-suffixes-left := $(libm-tests-base-normal)
1209 include $(o-iterator)
1210
1211 define o-iterator-doit
1212 $(foreach f,$(libm-test-funcs-all-static),\
1213             $(objpfx)$(o)-$(f)-static.o): CFLAGS += $(libm-test-no-inline-cflags)
1214 endef
1215 object-suffixes-left := $(libm-tests-base-normal)
1216 include $(o-iterator)
1217
1218 define o-iterator-doit
1219 $(foreach f,$(libm-test-funcs-narrow),\
1220             $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-no-inline-cflags)
1221 endef
1222 object-suffixes-left := $(libm-tests-base-narrow)
1223 include $(o-iterator)
1224
1225 define o-iterator-doit
1226 $(foreach f,$($(o)-funcs),\
1227             $(objpfx)test-$(o)-$(f).o): CFLAGS += $(libm-test-vec-cflags)
1228 endef
1229 object-suffixes-left := $(libmvec-tests)
1230 include $(o-iterator)
1231
1232 define o-iterator-doit
1233 $(addprefix $(objpfx),\
1234             $(call libm-tests-for-type,$(o))): $(objpfx)libm-test-support-$(o).o
1235 endef
1236 object-suffixes-left := $(test-types)
1237 include $(o-iterator)
1238
1239 define o-iterator-doit
1240 $(addprefix $(objpfx),\
1241             $(call libm-tests-for-type-static,$(o))): $(objpfx)libm-test-support-$(o)-static.o
1242 endef
1243 object-suffixes-left := $(test-types)
1244 include $(o-iterator)
1245
1246 define o-iterator-doit
1247 $(objpfx)libm-test-support-$(o).o: CFLAGS += $(libm-test-no-inline-cflags)
1248 endef
1249 object-suffixes-left := $(test-types)
1250 include $(o-iterator)
1251
1252 # Run the math programs to automatically generate ULPs files.
1253 .PHONY: regen-ulps
1254
1255 run-regen-ulps = $(test-wrapper-env) \
1256             $(run-program-env) \
1257             $($*-ENV) $(rtld-prefix) $(objpfx)$${run}
1258
1259 regen-ulps: $(addprefix $(objpfx),$(libm-tests))
1260         rm -f $(objpfx)ULPs; rm -f $(objpfx)NewUlps; \
1261         cp $(ulps-file) $(objpfx)libm-test-ulps; \
1262         for run in $(libm-tests); do \
1263           echo "Regenerating ULPs for $${run}"; \
1264           $(run-regen-ulps) -u -o $(objpfx); \
1265           cat $(objpfx)ULPs >> $(objpfx)libm-test-ulps; \
1266           rm $(objpfx)ULPs; \
1267         done; \
1268         $(PYTHON) gen-libm-test.py -n $(objpfx)NewUlps \
1269                                    -u $(objpfx)libm-test-ulps; \
1270         echo "Automatic regeneration of ULPs complete."; \
1271         echo "Difference between the current baseline and the new baseline is:";\
1272         diff -urN $(ulps-file) $(objpfx)NewUlps; \
1273         echo "Copy $(objpfx)NewUlps to $(ulps-file) (relative to source)."
1274
1275 # The generated sysd-rules file defines rules like this for sources
1276 # coming from sysdeps/ directories.  These rules find the generic sources.
1277 define o-iterator-doit
1278 $(objpfx)m_%$o: s_%.c $(before-compile); $$(compile-command.c)
1279 endef
1280 object-suffixes-left := $(all-object-suffixes)
1281 include $(o-iterator)
1282
1283 # Likewise, for those generated files shared with libc.
1284 define o-iterator-doit
1285 $(objpfx)m_%$o: $(objpfx)s_%.c $(before-compile); $$(compile-command.c)
1286 endef
1287 object-suffixes-left := $(all-object-suffixes)
1288 include $(o-iterator)
1289
1290 ifneq ($(long-double-fcts),yes)
1291 # The `double' and `long double' types are the same on this machine.
1292 # We won't compile the `long double' code at all.  Tell the `double' code
1293 # to define aliases for the `FUNCl' names.
1294 math-CPPFLAGS += -DNO_LONG_DOUBLE
1295 # GCC 10 diagnoses aliases with types conflicting with built-in
1296 # functions.
1297 CFLAGS-w_acos.c += -fno-builtin-acosl
1298 CFLAGS-w_acosh.c += -fno-builtin-acoshl
1299 CFLAGS-w_asin.c += -fno-builtin-asinl
1300 CFLAGS-s_asinh.c += -fno-builtin-asinhl
1301 CFLAGS-s_atan.c += -fno-builtin-atanl
1302 CFLAGS-w_atan2.c += -fno-builtin-atan2l
1303 CFLAGS-w_atanh.c += -fno-builtin-atanhl
1304 CFLAGS-s_cabs.c += -fno-builtin-cabsl
1305 CFLAGS-s_cacos.c += -fno-builtin-cacosl
1306 CFLAGS-s_cacosh.c += -fno-builtin-cacoshl
1307 CFLAGS-s_canonicalize.c += -fno-builtin-canonicalizel
1308 CFLAGS-s_carg.c += -fno-builtin-cargl
1309 CFLAGS-s_casin.c += -fno-builtin-casinl
1310 CFLAGS-s_casinh.c += -fno-builtin-casinhl
1311 CFLAGS-s_catan.c += -fno-builtin-catanl
1312 CFLAGS-s_catanh.c += -fno-builtin-catanhl
1313 CFLAGS-s_cbrt.c += -fno-builtin-cbrtl
1314 CFLAGS-s_ccos.c += -fno-builtin-ccosl
1315 CFLAGS-s_ccosh.c += -fno-builtin-ccoshl
1316 CFLAGS-s_ceil.c += -fno-builtin-ceill
1317 CFLAGS-s_cexp.c += -fno-builtin-cexpl
1318 CFLAGS-s_cimag.c += -fno-builtin-cimagl
1319 CFLAGS-s_clog.c += -fno-builtin-clogl
1320 CFLAGS-s_clog10.c += -fno-builtin-clog10l
1321 CFLAGS-s_conj.c += -fno-builtin-conjl
1322 CFLAGS-s_copysign.c += -fno-builtin-copysignl
1323 CFLAGS-s_cos.c += -fno-builtin-cosl
1324 CFLAGS-w_cosh.c += -fno-builtin-coshl
1325 CFLAGS-s_cpow.c += -fno-builtin-cpowl
1326 CFLAGS-s_cproj.c += -fno-builtin-cprojl
1327 CFLAGS-s_creal.c += -fno-builtin-creall
1328 CFLAGS-s_csin.c += -fno-builtin-csinl
1329 CFLAGS-s_csinh.c += -fno-builtin-csinhl
1330 CFLAGS-s_csqrt.c += -fno-builtin-csqrtl
1331 CFLAGS-s_ctan.c += -fno-builtin-ctanl
1332 CFLAGS-s_ctanh.c += -fno-builtin-ctanhl
1333 CFLAGS-s_erf.c += -fno-builtin-erfl
1334 CFLAGS-s_erfc.c += -fno-builtin-erfcl
1335 CFLAGS-e_exp.c += -fno-builtin-expl
1336 CFLAGS-w_exp10.c += -fno-builtin-exp10l
1337 CFLAGS-s_exp10m1.c += -fno-builtin-exp10m1l
1338 CFLAGS-e_exp2.c += -fno-builtin-exp2l
1339 CFLAGS-s_exp2m1.c += -fno-builtin-exp2m1l
1340 CFLAGS-s_expm1.c += -fno-builtin-expm1l
1341 CFLAGS-s_f32xaddf64.c += -fno-builtin-daddl
1342 CFLAGS-s_f32xdivf64.c += -fno-builtin-ddivl
1343 CFLAGS-s_f32xfmaf64.c += -fno-builtin-dfmal
1344 CFLAGS-s_f32xmulf64.c += -fno-builtin-dmull
1345 CFLAGS-s_f32xsqrtf64.c += -fno-builtin-dsqrtl
1346 CFLAGS-s_f32xsubf64.c += -fno-builtin-dsubl
1347 CFLAGS-s_fabs.c += -fno-builtin-fabsl
1348 CFLAGS-s_fadd.c += -fno-builtin-faddl
1349 CFLAGS-s_fdim.c += -fno-builtin-fdiml
1350 CFLAGS-s_fdiv.c += -fno-builtin-fdivl
1351 CFLAGS-s_ffma.c += -fno-builtin-ffmal
1352 CFLAGS-s_finite.c += -fno-builtin-finitel
1353 CFLAGS-s_floor.c += -fno-builtin-floorl
1354 CFLAGS-s_fma.c += -fno-builtin-fmal
1355 CFLAGS-s_fmax.c += -fno-builtin-fmaxl
1356 CFLAGS-s_fmaximum.c += -fno-builtin-fmaximuml
1357 CFLAGS-s_fmaximum_mag.c += -fno-builtin-fmaximum_magl
1358 CFLAGS-s_fmaximum_mag_num.c += -fno-builtin-fmaximum_mag_numl
1359 CFLAGS-s_fmaximum_num.c += -fno-builtin-fmaximum_numl
1360 CFLAGS-s_fmaxmag.c += -fno-builtin-fmaxmagl
1361 CFLAGS-s_fmin.c += -fno-builtin-fminl
1362 CFLAGS-s_fminimum.c += -fno-builtin-fminimuml
1363 CFLAGS-s_fminimum_mag.c += -fno-builtin-fminimum_magl
1364 CFLAGS-s_fminimum_mag_num.c += -fno-builtin-fminimum_mag_numl
1365 CFLAGS-s_fminimum_num.c += -fno-builtin-fminimum_numl
1366 CFLAGS-s_fminmag.c += -fno-builtin-fminmagl
1367 CFLAGS-w_fmod.c += -fno-builtin-fmodl
1368 CFLAGS-s_fmul.c += -fno-builtin-fmull
1369 CFLAGS-s_frexp.c += -fno-builtin-frexpl
1370 CFLAGS-s_fromfp.c += -fno-builtin-fromfpl
1371 CFLAGS-s_fromfpx.c += -fno-builtin-fromfpxl
1372 CFLAGS-s_fsqrt.c += -fno-builtin-fsqrtl
1373 CFLAGS-s_fsub.c += -fno-builtin-fsubl
1374 CFLAGS-s_getpayload.c += -fno-builtin-getpayloadl
1375 CFLAGS-w_hypot.c += -fno-builtin-hypotl
1376 CFLAGS-w_ilogb.c += -fno-builtin-ilogbl
1377 CFLAGS-s_isinf.c += -fno-builtin-isinfl
1378 CFLAGS-s_isnan.c += -fno-builtin-isnanl
1379 CFLAGS-w_j0.c += -fno-builtin-j0l
1380 CFLAGS-w_j1.c += -fno-builtin-j1l
1381 CFLAGS-w_jn.c += -fno-builtin-jnl
1382 CFLAGS-s_ldexp.c += -fno-builtin-ldexpl
1383 CFLAGS-w_lgamma.c += -fno-builtin-lgammal
1384 CFLAGS-w_lgamma_r.c += -fno-builtin-lgammal_r
1385 CFLAGS-w_llogb.c += -fno-builtin-llogbl
1386 CFLAGS-s_llrint.c += -fno-builtin-llrintl
1387 CFLAGS-s_llround.c += -fno-builtin-llroundl
1388 CFLAGS-e_log.c += -fno-builtin-logl
1389 CFLAGS-w_log10.c += -fno-builtin-log10l
1390 CFLAGS-s_log10p1.c += -fno-builtin-log10p1l
1391 CFLAGS-w_log1p.c += -fno-builtin-log1pl -fno-builtin-logp1l
1392 CFLAGS-e_log2.c += -fno-builtin-log2l
1393 CFLAGS-s_log2p1.c += -fno-builtin-log2p1l
1394 CFLAGS-s_logb.c += -fno-builtin-logbl
1395 CFLAGS-s_lrint.c += -fno-builtin-lrintl
1396 CFLAGS-s_lround.c += -fno-builtin-lroundl
1397 CFLAGS-s_modf.c += -fno-builtin-modfl
1398 CFLAGS-s_nan.c += -fno-builtin-nanl
1399 CFLAGS-s_nearbyint.c += -fno-builtin-nearbyintl
1400 CFLAGS-s_nextafter.c += -fno-builtin-nextafterl
1401 CFLAGS-s_nextdown.c += -fno-builtin-nextdownl
1402 CFLAGS-s_nexttoward.c += -fno-builtin-nexttoward -fno-builtin-nexttowardl
1403 CFLAGS-s_nexttowardf.c += -fno-builtin-nexttowardf
1404 CFLAGS-s_nextup.c += -fno-builtin-nextupl
1405 CFLAGS-e_pow.c += -fno-builtin-powl
1406 CFLAGS-w_remainder.c += -fno-builtin-remainderl -fno-builtin-dreml
1407 CFLAGS-s_remquo.c += -fno-builtin-remquol
1408 CFLAGS-s_rint.c += -fno-builtin-rintl
1409 CFLAGS-s_round.c += -fno-builtin-roundl
1410 CFLAGS-s_roundeven.c += -fno-builtin-roundevenl
1411 CFLAGS-w_scalb.c += -fno-builtin-scalbl
1412 CFLAGS-w_scalbln.c += -fno-builtin-scalblnl
1413 CFLAGS-s_scalbn.c += -fno-builtin-scalbnl
1414 CFLAGS-s_setpayload.c += -fno-builtin-setpayloadl
1415 CFLAGS-s_setpayloadsig.c += -fno-builtin-setpayloadsigl
1416 CFLAGS-s_significand.c += -fno-builtin-significandl
1417 CFLAGS-s_sin.c += -fno-builtin-sinl
1418 CFLAGS-s_sincos.c += -fno-builtin-sincosl
1419 CFLAGS-w_sinh.c += -fno-builtin-sinhl
1420 CFLAGS-w_sqrt.c += -fno-builtin-sqrtl
1421 CFLAGS-s_tan.c += -fno-builtin-tanl
1422 CFLAGS-s_tanh.c += -fno-builtin-tanhl
1423 CFLAGS-w_tgamma.c += -fno-builtin-tgammal
1424 CFLAGS-s_totalorder.c += -fno-builtin-totalorderl
1425 CFLAGS-s_totalordermag.c += -fno-builtin-totalordermagl
1426 CFLAGS-s_trunc.c += -fno-builtin-truncl
1427 CFLAGS-s_ufromfp.c += -fno-builtin-ufromfpl
1428 CFLAGS-s_ufromfpx.c += -fno-builtin-ufromfpxl
1429 CFLAGS-s_y0.c += -fno-builtin-y0l
1430 CFLAGS-s_y1.c += -fno-builtin-y1l
1431 CFLAGS-s_yn.c += -fno-builtin-ynl
1432 endif
1433
1434 # Likewise, for _Float32x and _Float64 aliases.
1435 CFLAGS-w_acos.c += -fno-builtin-acosf32x -fno-builtin-acosf64
1436 CFLAGS-w_acosh.c += -fno-builtin-acoshf32x -fno-builtin-acoshf64
1437 CFLAGS-w_asin.c += -fno-builtin-asinf32x -fno-builtin-asinf64
1438 CFLAGS-s_asinh.c += -fno-builtin-asinhf32x -fno-builtin-asinhf64
1439 CFLAGS-s_atan.c += -fno-builtin-atanf32x -fno-builtin-atanf64
1440 CFLAGS-w_atan2.c += -fno-builtin-atan2f32x -fno-builtin-atan2f64
1441 CFLAGS-w_atanh.c += -fno-builtin-atanhf32x -fno-builtin-atanhf64
1442 CFLAGS-s_cabs.c += -fno-builtin-cabsf32x -fno-builtin-cabsf64
1443 CFLAGS-s_cacos.c += -fno-builtin-cacosf32x -fno-builtin-cacosf64
1444 CFLAGS-s_cacosh.c += -fno-builtin-cacoshf32x -fno-builtin-cacoshf64
1445 CFLAGS-s_canonicalize.c += -fno-builtin-canonicalizef32x -fno-builtin-canonicalizef64
1446 CFLAGS-s_carg.c += -fno-builtin-cargf32x -fno-builtin-cargf64
1447 CFLAGS-s_casin.c += -fno-builtin-casinf32x -fno-builtin-casinf64
1448 CFLAGS-s_casinh.c += -fno-builtin-casinhf32x -fno-builtin-casinhf64
1449 CFLAGS-s_catan.c += -fno-builtin-catanf32x -fno-builtin-catanf64
1450 CFLAGS-s_catanh.c += -fno-builtin-catanhf32x -fno-builtin-catanhf64
1451 CFLAGS-s_cbrt.c += -fno-builtin-cbrtf32x -fno-builtin-cbrtf64
1452 CFLAGS-s_ccos.c += -fno-builtin-ccosf32x -fno-builtin-ccosf64
1453 CFLAGS-s_ccosh.c += -fno-builtin-ccoshf32x -fno-builtin-ccoshf64
1454 CFLAGS-s_ceil.c += -fno-builtin-ceilf32x -fno-builtin-ceilf64
1455 CFLAGS-s_cexp.c += -fno-builtin-cexpf32x -fno-builtin-cexpf64
1456 CFLAGS-s_cimag.c += -fno-builtin-cimagf32x -fno-builtin-cimagf64
1457 CFLAGS-s_clog.c += -fno-builtin-clogf32x -fno-builtin-clogf64
1458 CFLAGS-s_clog10.c += -fno-builtin-clog10f32x -fno-builtin-clog10f64
1459 CFLAGS-s_conj.c += -fno-builtin-conjf32x -fno-builtin-conjf64
1460 CFLAGS-s_copysign.c += -fno-builtin-copysignf32x -fno-builtin-copysignf64
1461 CFLAGS-s_cos.c += -fno-builtin-cosf32x -fno-builtin-cosf64
1462 CFLAGS-w_cosh.c += -fno-builtin-coshf32x -fno-builtin-coshf64
1463 CFLAGS-s_cpow.c += -fno-builtin-cpowf32x -fno-builtin-cpowf64
1464 CFLAGS-s_cproj.c += -fno-builtin-cprojf32x -fno-builtin-cprojf64
1465 CFLAGS-s_creal.c += -fno-builtin-crealf32x -fno-builtin-crealf64
1466 CFLAGS-s_csin.c += -fno-builtin-csinf32x -fno-builtin-csinf64
1467 CFLAGS-s_csinh.c += -fno-builtin-csinhf32x -fno-builtin-csinhf64
1468 CFLAGS-s_csqrt.c += -fno-builtin-csqrtf32x -fno-builtin-csqrtf64
1469 CFLAGS-s_ctan.c += -fno-builtin-ctanf32x -fno-builtin-ctanf64
1470 CFLAGS-s_ctanh.c += -fno-builtin-ctanhf32x -fno-builtin-ctanhf64
1471 CFLAGS-s_erf.c += -fno-builtin-erff32x -fno-builtin-erff64
1472 CFLAGS-s_erfc.c += -fno-builtin-erfcf32x -fno-builtin-erfcf64
1473 CFLAGS-e_exp.c += -fno-builtin-expf32x -fno-builtin-expf64
1474 CFLAGS-w_exp10.c += -fno-builtin-exp10f32x -fno-builtin-exp10f64
1475 CFLAGS-s_exp10m1.c += -fno-builtin-exp10m1f32x -fno-builtin-exp10m1f64
1476 CFLAGS-e_exp2.c += -fno-builtin-exp2f32x -fno-builtin-exp2f64
1477 CFLAGS-s_exp2m1.c += -fno-builtin-exp2m1f32x -fno-builtin-exp2m1f64
1478 CFLAGS-s_expm1.c += -fno-builtin-expm1f32x -fno-builtin-expm1f64
1479 CFLAGS-s_fabs.c += -fno-builtin-fabsf32x -fno-builtin-fabsf64
1480 CFLAGS-s_fadd.c += -fno-builtin-f32addf32x -fno-builtin-f32addf64
1481 CFLAGS-s_fdim.c += -fno-builtin-fdimf32x -fno-builtin-fdimf64
1482 CFLAGS-s_fdiv.c += -fno-builtin-f32divf32x -fno-builtin-f32divf64
1483 CFLAGS-s_ffma.c += -fno-builtin-f32fmaf32x -fno-builtin-f32fmaf64
1484 CFLAGS-s_floor.c += -fno-builtin-floorf32x -fno-builtin-floorf64
1485 CFLAGS-s_fma.c += -fno-builtin-fmaf32x -fno-builtin-fmaf64
1486 CFLAGS-s_fmax.c += -fno-builtin-fmaxf32x -fno-builtin-fmaxf64
1487 CFLAGS-s_fmaximum.c += -fno-builtin-fmaximumf32x -fno-builtin-fmaximumf64
1488 CFLAGS-s_fmaximum_mag.c += -fno-builtin-fmaximum_magf32x -fno-builtin-fmaximum_magf64
1489 CFLAGS-s_fmaximum_mag_num.c += -fno-builtin-fmaximum_mag_numf32x -fno-builtin-fmaximum_mag_numf64
1490 CFLAGS-s_fmaximum_num.c += -fno-builtin-fmaximum_numf32x -fno-builtin-fmaximum_numf64
1491 CFLAGS-s_fmaxmag.c += -fno-builtin-fmaxmagf32x -fno-builtin-fmaxmagf64
1492 CFLAGS-s_fmin.c += -fno-builtin-fminf32x -fno-builtin-fminf64
1493 CFLAGS-s_fminimum.c += -fno-builtin-fminimumf32x -fno-builtin-fminimumf64
1494 CFLAGS-s_fminimum_mag.c += -fno-builtin-fminimum_magf32x -fno-builtin-fminimum_magf64
1495 CFLAGS-s_fminimum_mag_num.c += -fno-builtin-fminimum_mag_numf32x -fno-builtin-fminimum_mag_numf64
1496 CFLAGS-s_fminimum_num.c += -fno-builtin-fminimum_numf32x -fno-builtin-fminimum_numf64
1497 CFLAGS-s_fminmag.c += -fno-builtin-fminmagf32x -fno-builtin-fminmagf64
1498 CFLAGS-w_fmod.c += -fno-builtin-fmodf32x -fno-builtin-fmodf64
1499 CFLAGS-s_fmul.c += -fno-builtin-f32mulf32x -fno-builtin-f32mulf64
1500 CFLAGS-s_frexp.c += -fno-builtin-frexpf32x -fno-builtin-frexpf64
1501 CFLAGS-s_fromfp.c += -fno-builtin-fromfpf32x -fno-builtin-fromfpf64
1502 CFLAGS-s_fromfpx.c += -fno-builtin-fromfpxf32x -fno-builtin-fromfpxf64
1503 CFLAGS-s_fsqrt.c += -fno-builtin-f32sqrtf32x -fno-builtin-f32sqrtf64
1504 CFLAGS-s_fsub.c += -fno-builtin-f32subf32x -fno-builtin-f32subf64
1505 CFLAGS-s_getpayload.c += -fno-builtin-getpayloadf32x -fno-builtin-getpayloadf64
1506 CFLAGS-w_hypot.c += -fno-builtin-hypotf32x -fno-builtin-hypotf64
1507 CFLAGS-w_ilogb.c += -fno-builtin-ilogbf32x -fno-builtin-ilogbf64
1508 CFLAGS-w_j0.c += -fno-builtin-j0f32x -fno-builtin-j0f64
1509 CFLAGS-w_j1.c += -fno-builtin-j1f32x -fno-builtin-j1f64
1510 CFLAGS-w_jn.c += -fno-builtin-jnf32x -fno-builtin-jnf64
1511 CFLAGS-s_ldexp.c += -fno-builtin-ldexpf32x -fno-builtin-ldexpf64
1512 CFLAGS-w_lgamma.c += -fno-builtin-lgammaf32x -fno-builtin-lgammaf64
1513 CFLAGS-w_lgamma_r.c += -fno-builtin-lgammaf32x_r -fno-builtin-lgammaf64_r
1514 CFLAGS-w_llogb.c += -fno-builtin-llogbf32x -fno-builtin-llogbf64
1515 CFLAGS-s_llrint.c += -fno-builtin-llrintf32x -fno-builtin-llrintf64
1516 CFLAGS-s_llround.c += -fno-builtin-llroundf32x -fno-builtin-llroundf64
1517 CFLAGS-e_log.c += -fno-builtin-logf32x -fno-builtin-logf64
1518 CFLAGS-w_log10.c += -fno-builtin-log10f32x -fno-builtin-log10f64
1519 CFLAGS-s_log10p1.c += -fno-builtin-log10p1f32x -fno-builtin-log10p1f64
1520 CFLAGS-w_log1p.c += -fno-builtin-log1pf32x -fno-builtin-log1pf64 -fno-builtin-logp1f32x -fno-builtin-logp1f64
1521 CFLAGS-e_log2.c += -fno-builtin-log2f32x -fno-builtin-log2f64
1522 CFLAGS-s_log2p1.c += -fno-builtin-log2p1f32x -fno-builtin-log2p1f64
1523 CFLAGS-s_logb.c += -fno-builtin-logbf32x -fno-builtin-logbf64
1524 CFLAGS-s_lrint.c += -fno-builtin-lrintf32x -fno-builtin-lrintf64
1525 CFLAGS-s_lround.c += -fno-builtin-lroundf32x -fno-builtin-lroundf64
1526 CFLAGS-s_modf.c += -fno-builtin-modff32x -fno-builtin-modff64
1527 CFLAGS-s_nan.c += -fno-builtin-nanf32x -fno-builtin-nanf64
1528 CFLAGS-s_nearbyint.c += -fno-builtin-nearbyintf32x -fno-builtin-nearbyintf64
1529 CFLAGS-s_nextafter.c += -fno-builtin-nextafterf32x -fno-builtin-nextafterf64
1530 CFLAGS-s_nextdown.c += -fno-builtin-nextdownf32x -fno-builtin-nextdownf64
1531 CFLAGS-s_nextup.c += -fno-builtin-nextupf32x -fno-builtin-nextupf64
1532 CFLAGS-e_pow.c += -fno-builtin-powf32x -fno-builtin-powf64
1533 CFLAGS-w_remainder.c += -fno-builtin-remainderf32x -fno-builtin-remainderf64
1534 CFLAGS-s_remquo.c += -fno-builtin-remquof32x -fno-builtin-remquof64
1535 CFLAGS-s_rint.c += -fno-builtin-rintf32x -fno-builtin-rintf64
1536 CFLAGS-s_round.c += -fno-builtin-roundf32x -fno-builtin-roundf64
1537 CFLAGS-s_roundeven.c += -fno-builtin-roundevenf32x -fno-builtin-roundevenf64
1538 CFLAGS-w_scalbln.c += -fno-builtin-scalblnf32x -fno-builtin-scalblnf64
1539 CFLAGS-s_scalbn.c += -fno-builtin-scalbnf32x -fno-builtin-scalbnf64
1540 CFLAGS-s_setpayload.c += -fno-builtin-setpayloadf32x -fno-builtin-setpayloadf64
1541 CFLAGS-s_setpayloadsig.c += -fno-builtin-setpayloadsigf32x -fno-builtin-setpayloadsigf64
1542 CFLAGS-s_sin.c += -fno-builtin-sinf32x -fno-builtin-sinf64
1543 CFLAGS-s_sincos.c += -fno-builtin-sincosf32x -fno-builtin-sincosf64
1544 CFLAGS-w_sinh.c += -fno-builtin-sinhf32x -fno-builtin-sinhf64
1545 CFLAGS-w_sqrt.c += -fno-builtin-sqrtf32x -fno-builtin-sqrtf64
1546 CFLAGS-s_tan.c += -fno-builtin-tanf32x -fno-builtin-tanf64
1547 CFLAGS-s_tanh.c += -fno-builtin-tanhf32x -fno-builtin-tanhf64
1548 CFLAGS-w_tgamma.c += -fno-builtin-tgammaf32x -fno-builtin-tgammaf64
1549 CFLAGS-s_totalorder.c += -fno-builtin-totalorderf32x -fno-builtin-totalorderf64
1550 CFLAGS-s_totalordermag.c += -fno-builtin-totalordermagf32x -fno-builtin-totalordermagf64
1551 CFLAGS-s_trunc.c += -fno-builtin-truncf32x -fno-builtin-truncf64
1552 CFLAGS-s_ufromfp.c += -fno-builtin-ufromfpf32x -fno-builtin-ufromfpf64
1553 CFLAGS-s_ufromfpx.c += -fno-builtin-ufromfpxf32x -fno-builtin-ufromfpxf64
1554 CFLAGS-s_y0.c += -fno-builtin-y0f32x -fno-builtin-y0f64
1555 CFLAGS-s_y1.c += -fno-builtin-y1f32x -fno-builtin-y1f64
1556 CFLAGS-s_yn.c += -fno-builtin-ynf32x -fno-builtin-ynf64
1557
1558 # Likewise, for _Float32 aliases.
1559 CFLAGS-w_acosf.c += -fno-builtin-acosf32
1560 CFLAGS-w_acoshf.c += -fno-builtin-acoshf32
1561 CFLAGS-w_asinf.c += -fno-builtin-asinf32
1562 CFLAGS-s_asinhf.c += -fno-builtin-asinhf32
1563 CFLAGS-s_atanf.c += -fno-builtin-atanf32
1564 CFLAGS-w_atan2f.c += -fno-builtin-atan2f32
1565 CFLAGS-w_atanhf.c += -fno-builtin-atanhf32
1566 CFLAGS-s_cabsf.c += -fno-builtin-cabsf32
1567 CFLAGS-s_cacosf.c += -fno-builtin-cacosf32
1568 CFLAGS-s_cacoshf.c += -fno-builtin-cacoshf32
1569 CFLAGS-s_canonicalizef.c += -fno-builtin-canonicalizef32
1570 CFLAGS-s_cargf.c += -fno-builtin-cargf32
1571 CFLAGS-s_casinf.c += -fno-builtin-casinf32
1572 CFLAGS-s_casinhf.c += -fno-builtin-casinhf32
1573 CFLAGS-s_catanf.c += -fno-builtin-catanf32
1574 CFLAGS-s_catanhf.c += -fno-builtin-catanhf32
1575 CFLAGS-s_cbrtf.c += -fno-builtin-cbrtf32
1576 CFLAGS-s_ccosf.c += -fno-builtin-ccosf32
1577 CFLAGS-s_ccoshf.c += -fno-builtin-ccoshf32
1578 CFLAGS-s_ceilf.c += -fno-builtin-ceilf32
1579 CFLAGS-s_cexpf.c += -fno-builtin-cexpf32
1580 CFLAGS-s_cimagf.c += -fno-builtin-cimagf32
1581 CFLAGS-s_clogf.c += -fno-builtin-clogf32
1582 CFLAGS-s_clog10f.c += -fno-builtin-clog10f32
1583 CFLAGS-s_conjf.c += -fno-builtin-conjf32
1584 CFLAGS-s_copysignf.c += -fno-builtin-copysignf32
1585 CFLAGS-s_cosf.c += -fno-builtin-cosf32
1586 CFLAGS-w_coshf.c += -fno-builtin-coshf32
1587 CFLAGS-s_cpowf.c += -fno-builtin-cpowf32
1588 CFLAGS-s_cprojf.c += -fno-builtin-cprojf32
1589 CFLAGS-s_crealf.c += -fno-builtin-crealf32
1590 CFLAGS-s_csinf.c += -fno-builtin-csinf32
1591 CFLAGS-s_csinhf.c += -fno-builtin-csinhf32
1592 CFLAGS-s_csqrtf.c += -fno-builtin-csqrtf32
1593 CFLAGS-s_ctanf.c += -fno-builtin-ctanf32
1594 CFLAGS-s_ctanhf.c += -fno-builtin-ctanhf32
1595 CFLAGS-s_erff.c += -fno-builtin-erff32
1596 CFLAGS-s_erfcf.c += -fno-builtin-erfcf32
1597 CFLAGS-e_expf.c += -fno-builtin-expf32
1598 CFLAGS-w_exp10f.c += -fno-builtin-exp10f32
1599 CFLAGS-s_exp10m1f.c += -fno-builtin-exp10m1f32
1600 CFLAGS-e_exp2f.c += -fno-builtin-exp2f32
1601 CFLAGS-s_exp2m1f.c += -fno-builtin-exp2m1f32
1602 CFLAGS-s_expm1f.c += -fno-builtin-expm1f32
1603 CFLAGS-s_fabsf.c += -fno-builtin-fabsf32
1604 CFLAGS-s_fdimf.c += -fno-builtin-fdimf32
1605 CFLAGS-s_floorf.c += -fno-builtin-floorf32
1606 CFLAGS-s_fmaf.c += -fno-builtin-fmaf32
1607 CFLAGS-s_fmaxf.c += -fno-builtin-fmaxf32
1608 CFLAGS-s_fmaximumf.c += -fno-builtin-fmaximumf32
1609 CFLAGS-s_fmaximum_magf.c += -fno-builtin-fmaximum_magf32
1610 CFLAGS-s_fmaximum_mag_numf.c += -fno-builtin-fmaximum_mag_numf32
1611 CFLAGS-s_fmaximum_numf.c += -fno-builtin-fmaximum_numf32
1612 CFLAGS-s_fmaxmagf.c += -fno-builtin-fmaxmagf32
1613 CFLAGS-s_fminf.c += -fno-builtin-fminf32
1614 CFLAGS-s_fminimumf.c += -fno-builtin-fminimumf32
1615 CFLAGS-s_fminimum_magf.c += -fno-builtin-fminimum_magf32
1616 CFLAGS-s_fminimum_mag_numf.c += -fno-builtin-fminimum_mag_numf32
1617 CFLAGS-s_fminimum_numf.c += -fno-builtin-fminimum_numf32
1618 CFLAGS-s_fminmagf.c += -fno-builtin-fminmagf32
1619 CFLAGS-w_fmodf.c += -fno-builtin-fmodf32
1620 CFLAGS-s_frexpf.c += -fno-builtin-frexpf32
1621 CFLAGS-s_fromfpf.c += -fno-builtin-fromfpf32
1622 CFLAGS-s_fromfpxf.c += -fno-builtin-fromfpxf32
1623 CFLAGS-s_getpayloadf.c += -fno-builtin-getpayloadf32
1624 CFLAGS-w_hypotf.c += -fno-builtin-hypotf32
1625 CFLAGS-w_ilogbf.c += -fno-builtin-ilogbf32
1626 CFLAGS-w_j0f.c += -fno-builtin-j0f32
1627 CFLAGS-w_j1f.c += -fno-builtin-j1f32
1628 CFLAGS-w_jnf.c += -fno-builtin-jnf32
1629 CFLAGS-s_ldexpf.c += -fno-builtin-ldexpf32
1630 CFLAGS-w_lgammaf.c += -fno-builtin-lgammaf32
1631 CFLAGS-w_lgammaf_r.c += -fno-builtin-lgammaf32_r
1632 CFLAGS-w_llogbf.c += -fno-builtin-llogbf32
1633 CFLAGS-s_llrintf.c += -fno-builtin-llrintf32
1634 CFLAGS-s_llroundf.c += -fno-builtin-llroundf32
1635 CFLAGS-e_logf.c += -fno-builtin-logf32
1636 CFLAGS-w_log10f.c += -fno-builtin-log10f32
1637 CFLAGS-s_log10p1f.c += -fno-builtin-log10p1f32
1638 CFLAGS-w_log1pf.c += -fno-builtin-log1pf32 -fno-builtin-logp1f32
1639 CFLAGS-e_log2f.c += -fno-builtin-log2f32
1640 CFLAGS-s_log2p1f.c += -fno-builtin-log2p1f32
1641 CFLAGS-s_logbf.c += -fno-builtin-logbf32
1642 CFLAGS-s_lrintf.c += -fno-builtin-lrintf32
1643 CFLAGS-s_lroundf.c += -fno-builtin-lroundf32
1644 CFLAGS-s_modff.c += -fno-builtin-modff32
1645 CFLAGS-s_nanf.c += -fno-builtin-nanf32
1646 CFLAGS-s_nearbyintf.c += -fno-builtin-nearbyintf32
1647 CFLAGS-s_nextafterf.c += -fno-builtin-nextafterf32
1648 CFLAGS-s_nextdownf.c += -fno-builtin-nextdownf32
1649 CFLAGS-s_nextupf.c += -fno-builtin-nextupf32
1650 CFLAGS-e_powf.c += -fno-builtin-powf32
1651 CFLAGS-w_remainderf.c += -fno-builtin-remainderf32
1652 CFLAGS-s_remquof.c += -fno-builtin-remquof32
1653 CFLAGS-s_rintf.c += -fno-builtin-rintf32
1654 CFLAGS-s_roundf.c += -fno-builtin-roundf32
1655 CFLAGS-s_roundevenf.c += -fno-builtin-roundevenf32
1656 CFLAGS-w_scalblnf.c += -fno-builtin-scalblnf32
1657 CFLAGS-s_scalbnf.c += -fno-builtin-scalbnf32
1658 CFLAGS-s_setpayloadf.c += -fno-builtin-setpayloadf32
1659 CFLAGS-s_setpayloadsigf.c += -fno-builtin-setpayloadsigf32
1660 CFLAGS-s_sinf.c += -fno-builtin-sinf32
1661 CFLAGS-s_sincosf.c += -fno-builtin-sincosf32
1662 CFLAGS-w_sinhf.c += -fno-builtin-sinhf32
1663 CFLAGS-w_sqrtf.c += -fno-builtin-sqrtf32
1664 CFLAGS-s_tanf.c += -fno-builtin-tanf32
1665 CFLAGS-s_tanhf.c += -fno-builtin-tanhf32
1666 CFLAGS-w_tgammaf.c += -fno-builtin-tgammaf32
1667 CFLAGS-s_totalorderf.c += -fno-builtin-totalorderf32
1668 CFLAGS-s_totalordermagf.c += -fno-builtin-totalordermagf32
1669 CFLAGS-s_truncf.c += -fno-builtin-truncf32
1670 CFLAGS-s_ufromfpf.c += -fno-builtin-ufromfpf32
1671 CFLAGS-s_ufromfpxf.c += -fno-builtin-ufromfpxf32
1672 CFLAGS-s_y0f.c += -fno-builtin-y0f32
1673 CFLAGS-s_y1f.c += -fno-builtin-y1f32
1674 CFLAGS-s_ynf.c += -fno-builtin-ynf32
1675
1676 # These files quiet sNaNs in a way that is optimized away without
1677 # -fsignaling-nans.
1678 CFLAGS-s_modf.c += $(config-cflags-signaling-nans)
1679 CFLAGS-s_modff.c += $(config-cflags-signaling-nans)
1680 CFLAGS-s_modfl.c += $(config-cflags-signaling-nans)
1681 CFLAGS-s_modff128.c += $(config-cflags-signaling-nans)
1682
1683 $(addprefix $(objpfx),\
1684             $(filter-out $(tests-static) $(libm-tests-vector),\
1685                          $(tests) $(tests-internal))): $(libm)
1686 $(addprefix $(objpfx),$(tests-static)): $(objpfx)libm.a
1687 define o-iterator-doit
1688 $(foreach f,$($(o)-funcs),\
1689             $(objpfx)test-$(o)-$(f)): $(objpfx)test-$(o)-wrappers.o \
1690                                       $(libm) $(libmvec)
1691 endef
1692 object-suffixes-left := $(libmvec-tests)
1693 include $(o-iterator)
1694
1695 $(objpfx)test-fenv-tls: $(shared-thread-library)