libstdc++-v3/linkage.m4

   1 dnl
   2 dnl This file contains macros for testing linkage.
   3 dnl
   4
   5 dnl
   6 dnl Check to see if the (math function) argument passed is
   7 dnl declared when using the c++ compiler
   8 dnl ASSUMES argument is a math function with ONE parameter
   9 dnl
  10 dnl GLIBCXX_CHECK_MATH_DECL_1
  11 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_1], [
  12   AC_MSG_CHECKING([for $1 declaration])
  13   if test x${glibcxx_cv_func_$1_use+set} != xset; then
  14     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
  15       AC_LANG_SAVE
  16       AC_LANG_CPLUSPLUS
  17       AC_TRY_COMPILE([#include <math.h>
  18                       #ifdef HAVE_IEEEFP_H
  19                       #include <ieeefp.h>
  20                       #endif
  21                      ],
  22                      [ $1(0);],
  23                       [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
  24       AC_LANG_RESTORE
  25     ])
  26   fi
  27   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
  28 ])
  29
  30
  31 dnl
  32 dnl Define autoheader template for using the underscore functions
  33 dnl For each parameter, create a macro where if func doesn't exist,
  34 dnl but _func does, then it will "#define func _func".
  35 dnl
  36 dnl GLIBCXX_MAYBE_UNDERSCORED_FUNCS
  37 AC_DEFUN([GLIBCXX_MAYBE_UNDERSCORED_FUNCS],
  38 [AC_FOREACH([glibcxx_ufunc], [$1],
  39   [AH_VERBATIM(_[]glibcxx_ufunc,
  40 [#if defined (]AS_TR_CPP(HAVE__[]glibcxx_ufunc)[) && ! defined (]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[)
  41 # define ]AS_TR_CPP(HAVE_[]glibcxx_ufunc)[ 1
  42 # define ]glibcxx_ufunc[ _]glibcxx_ufunc[
  43 #endif])])
  44 ])
  45
  46
  47 dnl
  48 dnl Check to see if the (math function) argument passed is
  49 dnl 1) declared when using the c++ compiler
  50 dnl 2) has "C" linkage
  51 dnl 3) if not, see if 1) and 2) for argument prepended with '_'
  52 dnl
  53 dnl Define HAVE_CARGF etc if "cargf" is declared and links
  54 dnl
  55 dnl argument 1 is name of function to check
  56 dnl
  57 dnl ASSUMES argument is a math function with ONE parameter
  58 dnl
  59 dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1
  60 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1], [
  61   GLIBCXX_CHECK_MATH_DECL_1($1)
  62   if test x$glibcxx_cv_func_$1_use = x"yes"; then
  63     AC_CHECK_FUNCS($1)
  64   else
  65     GLIBCXX_CHECK_MATH_DECL_1(_$1)
  66     if test x$glibcxx_cv_func__$1_use = x"yes"; then
  67       AC_CHECK_FUNCS(_$1)
  68     fi
  69   fi
  70   GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
  71 ])
  72
  73
  74 dnl
  75 dnl Like GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1, but does a bunch of
  76 dnl of functions at once.  It's an all-or-nothing check -- either
  77 dnl HAVE_XYZ is defined for each of the functions, or for none of them.
  78 dnl Doing it this way saves significant configure time.
  79 AC_DEFUN([GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1], [
  80   define([funclist],patsubst($3,\(\w+\)\(\W*\),\1 ))dnl
  81   AC_MSG_CHECKING([for $1 functions])
  82   AC_CACHE_VAL(glibcxx_cv_func_$2_use, [
  83     AC_LANG_SAVE
  84     AC_LANG_CPLUSPLUS
  85     AC_TRY_COMPILE([#include <math.h>],
  86                    patsubst(funclist,[\w+],[\& (0);]),
  87                    [glibcxx_cv_func_$2_use=yes],
  88                    [glibcxx_cv_func_$2_use=no])
  89     AC_LANG_RESTORE])
  90   AC_MSG_RESULT($glibcxx_cv_func_$2_use)
  91   if test x$glibcxx_cv_func_$2_use = x"yes"; then
  92     AC_CHECK_FUNCS(funclist)
  93   else
  94     AC_MSG_CHECKING([for _$1 functions])
  95     AC_CACHE_VAL(glibcxx_cv_func__$2_use, [
  96       AC_LANG_SAVE
  97       AC_LANG_CPLUSPLUS
  98       AC_TRY_COMPILE([#include <math.h>],
  99                      patsubst(funclist,[\w+],[_\& (0);]),
 100                      [glibcxx_cv_func__$2_use=yes],
 101                      [glibcxx_cv_func__$2_use=no])
 102       AC_LANG_RESTORE])
 103     AC_MSG_RESULT($glibcxx_cv_func__$2_use)
 104     if test x$glibcxx_cv_func__$2_use = x"yes"; then
 105       AC_CHECK_FUNCS(patsubst(funclist,[\w+],[_\&]))
 106     fi
 107   fi
 108   GLIBCXX_MAYBE_UNDERSCORED_FUNCS(funclist)
 109   undefine([funclist])
 110 ])
 111
 112 dnl
 113 dnl Check to see if the (math function) argument passed is
 114 dnl declared when using the c++ compiler
 115 dnl ASSUMES argument is a math function with TWO parameters
 116 dnl
 117 dnl GLIBCXX_CHECK_MATH_DECL_2
 118 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_2], [
 119   AC_MSG_CHECKING([for $1 declaration])
 120   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 121     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 122       AC_LANG_SAVE
 123       AC_LANG_CPLUSPLUS
 124       AC_TRY_COMPILE([#include <math.h>],
 125                      [ $1(0, 0);],
 126                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 127       AC_LANG_RESTORE
 128     ])
 129   fi
 130   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 131 ])
 132
 133 dnl
 134 dnl Check to see if the (math function) argument passed is
 135 dnl 1) declared when using the c++ compiler
 136 dnl 2) has "C" linkage
 137 dnl
 138 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 139 dnl
 140 dnl argument 1 is name of function to check
 141 dnl
 142 dnl ASSUMES argument is a math function with TWO parameters
 143 dnl
 144 dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2
 145 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2], [
 146   GLIBCXX_CHECK_MATH_DECL_2($1)
 147   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 148     AC_CHECK_FUNCS($1)
 149   else
 150     GLIBCXX_CHECK_MATH_DECL_2(_$1)
 151     if test x$glibcxx_cv_func__$1_use = x"yes"; then
 152       AC_CHECK_FUNCS(_$1)
 153     fi
 154   fi
 155   GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
 156 ])
 157
 158
 159 dnl
 160 dnl Check to see if the (math function) argument passed is
 161 dnl declared when using the c++ compiler
 162 dnl ASSUMES argument is a math function with THREE parameters
 163 dnl
 164 dnl GLIBCXX_CHECK_MATH_DECL_3
 165 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_3], [
 166   AC_MSG_CHECKING([for $1 declaration])
 167   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 168     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 169       AC_LANG_SAVE
 170       AC_LANG_CPLUSPLUS
 171       AC_TRY_COMPILE([#include <math.h>],
 172                      [ $1(0, 0, 0);],
 173                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 174       AC_LANG_RESTORE
 175     ])
 176   fi
 177   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 178 ])
 179
 180 dnl
 181 dnl Check to see if the (math function) argument passed is
 182 dnl 1) declared when using the c++ compiler
 183 dnl 2) has "C" linkage
 184 dnl
 185 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 186 dnl
 187 dnl argument 1 is name of function to check
 188 dnl
 189 dnl ASSUMES argument is a math function with THREE parameters
 190 dnl
 191 dnl GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3
 192 AC_DEFUN([GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3], [
 193   GLIBCXX_CHECK_MATH_DECL_3($1)
 194   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 195     AC_CHECK_FUNCS($1)
 196   else
 197     GLIBCXX_CHECK_MATH_DECL_3(_$1)
 198     if test x$glibcxx_cv_func__$1_use = x"yes"; then
 199       AC_CHECK_FUNCS(_$1)
 200     fi
 201   fi
 202   GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
 203 ])
 204
 205
 206 dnl
 207 dnl Check to see if the (stdlib function) argument passed is
 208 dnl 1) declared when using the c++ compiler
 209 dnl 2) has "C" linkage
 210 dnl
 211 dnl argument 1 is name of function to check
 212 dnl
 213 dnl ASSUMES argument is a stdlib function without parameters
 214 dnl
 215 dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0
 216 AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_0], [
 217   AC_MSG_CHECKING([for $1 declaration])
 218   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 219     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 220       AC_LANG_SAVE
 221       AC_LANG_CPLUSPLUS
 222       AC_TRY_COMPILE([#include <stdlib.h>],
 223                      [ $1();],
 224                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 225       AC_LANG_RESTORE
 226     ])
 227   fi
 228   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 229   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 230     AC_CHECK_FUNCS($1)
 231   fi
 232 ])
 233
 234
 235 dnl
 236 dnl Check to see if the (stdlib function) argument passed is
 237 dnl 1) declared when using the c++ compiler
 238 dnl 2) has "C" linkage
 239 dnl
 240 dnl argument 1 is name of function to check
 241 dnl
 242 dnl ASSUMES argument is a stdlib function with TWO parameters
 243 dnl
 244 dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2
 245 AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2], [
 246   AC_MSG_CHECKING([for $1 declaration])
 247   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 248     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 249       AC_LANG_SAVE
 250       AC_LANG_CPLUSPLUS
 251       AC_TRY_COMPILE([#include <stdlib.h>],
 252                      [ $1(0, 0);],
 253                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 254       AC_LANG_RESTORE
 255     ])
 256   fi
 257   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 258   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 259     AC_CHECK_FUNCS($1)
 260   fi
 261   GLIBCXX_MAYBE_UNDERSCORED_FUNCS($1)
 262 ])
 263
 264
 265 dnl
 266 dnl Check to see if the (stdlib function) argument passed is
 267 dnl 1) declared when using the c++ compiler
 268 dnl 2) has "C" linkage
 269 dnl
 270 dnl argument 1 is name of function to check
 271 dnl
 272 dnl ASSUMES argument is a stdlib function with THREE parameters
 273 dnl
 274 dnl GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3
 275 AC_DEFUN([GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3], [
 276   AC_MSG_CHECKING([for $1 declaration])
 277   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 278     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 279       AC_LANG_SAVE
 280       AC_LANG_CPLUSPLUS
 281       AC_TRY_COMPILE([#include <stdlib.h>],
 282                      [ $1(0, 0, 0);],
 283                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 284       AC_LANG_RESTORE
 285     ])
 286   fi
 287   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 288   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 289     AC_CHECK_FUNCS($1)
 290   fi
 291 ])
 292
 293 dnl
 294 dnl Because the builtins are picky picky picky about the arguments they take,
 295 dnl do an explict linkage tests here.
 296 dnl Check to see if the (math function) argument passed is
 297 dnl 1) declared when using the c++ compiler
 298 dnl 2) has "C" linkage
 299 dnl
 300 dnl Define HAVE_CARGF etc if "cargf" is declared and links
 301 dnl
 302 dnl argument 1 is name of function to check
 303 dnl
 304 dnl ASSUMES argument is a math function with ONE parameter
 305 dnl
 306 dnl GLIBCXX_CHECK_BUILTIN_MATH_DECL_LINKAGE_1
 307 AC_DEFUN([GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1], [
 308   AC_MSG_CHECKING([for $1 declaration])
 309   if test x${glibcxx_cv_func_$1_use+set} != xset; then
 310     AC_CACHE_VAL(glibcxx_cv_func_$1_use, [
 311       AC_LANG_SAVE
 312       AC_LANG_CPLUSPLUS
 313       AC_TRY_COMPILE([#include <math.h>],
 314                      [ $1(0);],
 315                      [glibcxx_cv_func_$1_use=yes], [glibcxx_cv_func_$1_use=no])
 316       AC_LANG_RESTORE
 317     ])
 318   fi
 319   AC_MSG_RESULT($glibcxx_cv_func_$1_use)
 320   if test x$glibcxx_cv_func_$1_use = x"yes"; then
 321     AC_MSG_CHECKING([for $1 linkage])
 322     if test x${glibcxx_cv_func_$1_link+set} != xset; then
 323       AC_CACHE_VAL(glibcxx_cv_func_$1_link, [
 324         AC_TRY_LINK([#include <math.h>],
 325                     [ $1(0);],
 326                     [glibcxx_cv_func_$1_link=yes], [glibcxx_cv_func_$1_link=no])
 327       ])
 328     fi
 329     AC_MSG_RESULT($glibcxx_cv_func_$1_link)
 330     define([NAME], [translit([$1],[abcdefghijklmnopqrstuvwxyz],
 331                                   [ABCDEFGHIJKLMNOPQRSTUVWXYZ])])
 332     if test x$glibcxx_cv_func_$1_link = x"yes"; then
 333       AC_DEFINE([HAVE_]NAME, 1, [Define if the compiler/host combination has $1.])
 334     fi
 335     undefine([NAME])
 336   fi
 337 ])
 338
 339
 340 dnl
 341 dnl Check to see what builtin math functions are supported
 342 dnl
 343 dnl check for __builtin_abs
 344 dnl check for __builtin_fabsf
 345 dnl check for __builtin_fabs
 346 dnl check for __builtin_fabl
 347 dnl check for __builtin_labs
 348 dnl check for __builtin_sqrtf
 349 dnl check for __builtin_sqrtl
 350 dnl check for __builtin_sqrt
 351 dnl check for __builtin_sinf
 352 dnl check for __builtin_sin
 353 dnl check for __builtin_sinl
 354 dnl check for __builtin_cosf
 355 dnl check for __builtin_cos
 356 dnl check for __builtin_cosl
 357 dnl
 358 dnl GLIBCXX_CHECK_BUILTIN_MATH_SUPPORT
 359 AC_DEFUN([GLIBCXX_CHECK_BUILTIN_MATH_SUPPORT], [
 360   dnl Test for builtin math functions.
 361   dnl These are made in gcc/c-common.c
 362   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_abs)
 363   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsf)
 364   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabs)
 365   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_fabsl)
 366   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_labs)
 367
 368   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtf)
 369   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrt)
 370   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sqrtl)
 371
 372   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinf)
 373   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sin)
 374   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_sinl)
 375
 376   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosf)
 377   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cos)
 378   GLIBCXX_CHECK_BUILTIN_MATH_DECL_AND_LINKAGE_1(__builtin_cosl)
 379 ])
 380
 381 dnl
 382 dnl Check to see what the underlying c library is like
 383 dnl These checks need to do two things:
 384 dnl 1) make sure the name is declared when using the c++ compiler
 385 dnl 2) make sure the name has "C" linkage
 386 dnl This might seem like overkill but experience has shown that it's not...
 387 dnl
 388 dnl Define HAVE_STRTOLD if "strtold" is declared and links
 389 dnl Define HAVE_STRTOF if "strtof" is declared and links
 390 dnl
 391 dnl GLIBCXX_CHECK_STDLIB_SUPPORT
 392 AC_DEFUN([GLIBCXX_CHECK_STDLIB_SUPPORT], [
 393   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 394   ac_save_CXXFLAGS="$CXXFLAGS"
 395   CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
 396
 397   GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtold)
 398   GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_2(strtof)
 399
 400   CXXFLAGS="$ac_save_CXXFLAGS"
 401 ])
 402
 403 dnl
 404 dnl Check to see what the underlying c library or math library is like.
 405 dnl These checks need to do two things:
 406 dnl 1) make sure the name is declared when using the c++ compiler
 407 dnl 2) make sure the name has "C" linkage
 408 dnl This might seem like overkill but experience has shown that it's not...
 409 dnl
 410 dnl Define HAVE_CARGF etc if "cargf" is found.
 411 dnl
 412 dnl GLIBCXX_CHECK_MATH_SUPPORT
 413 AC_DEFUN([GLIBCXX_CHECK_MATH_SUPPORT], [
 414   ac_test_CXXFLAGS="${CXXFLAGS+set}"
 415   ac_save_CXXFLAGS="$CXXFLAGS"
 416   CXXFLAGS='-fno-builtin -D_GNU_SOURCE'
 417
 418   dnl Check libm
 419   AC_CHECK_LIB(m, sin, libm="-lm")
 420   ac_save_LIBS="$LIBS"
 421   LIBS="$LIBS $libm"
 422
 423   dnl Check to see if certain C math functions exist.
 424   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinf)
 425   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnan)
 426   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finite)
 427   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(copysign)
 428   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincos)
 429   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fpclass)
 430   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(qfpclass)
 431   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypot)
 432
 433   dnl Check to see if basic C math functions have float versions.
 434   GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float trig,
 435                                           float_trig,
 436                                           acosf asinf atanf \
 437                                           cosf sinf tanf \
 438                                           coshf sinhf tanhf)
 439   GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(float round,
 440                                           float_round,
 441                                           ceilf floorf)
 442   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expf)
 443   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanf)
 444   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinff)
 445   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2f)
 446   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsf)
 447   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodf)
 448   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpf)
 449   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotf)
 450   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpf)
 451   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logf)
 452   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10f)
 453   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modff)
 454   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modf)
 455   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powf)
 456   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtf)
 457   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosf)
 458   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitef)
 459
 460   dnl Check to see if basic C math functions have long double versions.
 461   GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double trig,
 462                                           long_double_trig,
 463                                           acosl asinl atanl \
 464                                           cosl sinl tanl \
 465                                           coshl sinhl tanhl)
 466   GLIBCXX_CHECK_MATH_DECLS_AND_LINKAGES_1(long double round,
 467                                           long_double_round,
 468                                           ceill floorl)
 469   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isnanl)
 470   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(isinfl)
 471   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(copysignl)
 472   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(atan2l)
 473   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(expl)
 474   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(fabsl)
 475   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(fmodl)
 476   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(frexpl)
 477   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(hypotl)
 478   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(ldexpl)
 479   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(logl)
 480   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(log10l)
 481   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(modfl)
 482   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_2(powl)
 483   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(sqrtl)
 484   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_3(sincosl)
 485   GLIBCXX_CHECK_MATH_DECL_AND_LINKAGE_1(finitel)
 486
 487   LIBS="$ac_save_LIBS"
 488   CXXFLAGS="$ac_save_CXXFLAGS"
 489 ])
 490
 491
 492 dnl
 493 dnl Check to see if there is native support for complex
 494 dnl
 495 dnl Don't compile bits in math/* if native support exits.
 496 dnl
 497 dnl Define USE_COMPLEX_LONG_DOUBLE etc if "copysignl" is found.
 498 dnl
 499 dnl GLIBCXX_CHECK_COMPLEX_MATH_SUPPORT
 500 AC_DEFUN([GLIBCXX_CHECK_COMPLEX_MATH_SUPPORT], [
 501   dnl Check for complex versions of math functions of platform.  This will
 502   dnl always pass if libm is available, and fail if it isn't.  If it is
 503   dnl available, we assume we'll need it later, so add it to LIBS.
 504   AC_CHECK_LIB(m, main)
 505   AC_REPLACE_MATHFUNCS(copysignf)
 506
 507   dnl For __signbit to signbit conversions.
 508   dnl Not sure why this is done, as these will be macros mostly.
 509   dnl Should probably coordinate this with std_cmath.h.
 510   AC_CHECK_FUNCS([__signbit], , [LIBMATHOBJS="$LIBMATHOBJS signbit.lo"])
 511
 512   AC_CHECK_FUNCS([__signbitf], , [LIBMATHOBJS="$LIBMATHOBJS signbitf.lo"])
 513
 514   dnl Compile the long double complex functions only if the function
 515   dnl provides the non-complex long double functions that are needed.
 516   dnl Currently this includes copysignl, which should be
 517   dnl cached from the GLIBCXX_CHECK_MATH_SUPPORT macro, above.
 518   if test x$ac_cv_func_copysignl = x"yes"; then
 519     AC_CHECK_FUNCS([__signbitl], , [LIBMATHOBJS="$LIBMATHOBJS signbitl.lo"])
 520   fi
 521
 522   # Used in libmath/Makefile.am.
 523   if test -n "$LIBMATHOBJS"; then
 524     need_libmath=yes
 525   fi
 526   AC_SUBST(LIBMATHOBJS)
 527 ])
 528
 529
 530 # Check for functions in math library.
 531 # Ulrich Drepper <drepper@cygnus.com>, 1998.
 532 #
 533 # This file can be copied and used freely without restrictions.  It can
 534 # be used in projects which are not available under the GNU Public License
 535 # but which still want to provide support for the GNU gettext functionality.
 536 # Please note that the actual code is *not* freely available.
 537 #
 538 # serial 1
 539 #
 540 dnl AC_REPLACE_MATHFUNCS(FUNCTION...)
 541 AC_DEFUN([AC_REPLACE_MATHFUNCS],
 542 [AC_CHECK_FUNCS([$1], , [LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"])])