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