1_diff --git a/config.sub b/config.sub 2index 707e9e2efe8d..59dd372ec16c 100755 3--- a/config.sub 4+++ b/config.sub 5@@ -1359,6 +1359,7 @@ case $os in 6 | -sym* | -kopensolaris* | -plan9* \ 7 | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ 8 | -aos* | -aros* \ 9+ | -barrelfish* \ 10 | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ 11 | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ 12 | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ 13diff --git a/gcc/config.gcc b/gcc/config.gcc 14index 92d57ddf4fb3..8e794e895be0 100644 15--- a/gcc/config.gcc 16+++ b/gcc/config.gcc 17@@ -683,6 +683,12 @@ case ${target} in 18 tmake_file="${tmake_file} t-glibc" 19 target_has_targetcm=yes 20 ;; 21+*-*-barrelfish*) 22+ gas=yes 23+ gnu_ld=yes 24+ default_use_cxa_atexit=yes 25+ use_gcc_stdint=wrap 26+ ;; 27 *-*-netbsd*) 28 tmake_file="t-slibgcc" 29 gas=yes 30@@ -1212,9 +1218,18 @@ x86_64-*-darwin*) 31 i[34567]86-*-elf*) 32 tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h" 33 ;; 34+i[34567]86-pc-barrelfish*) 35+ tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/barrelfish-x86_32.h" 36+ ;; 37+i[34567]86-scc-barrelfish*) 38+ tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/barrelfish-scc.h" 39+ ;; 40 x86_64-*-elf*) 41 tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/x86-64.h" 42 ;; 43+x86_64-*-barrelfish*) 44+ tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/x86-64.h i386/barrelfish-x86_64.h" 45+ ;; 46 i[34567]86-*-rdos*) 47 tm_file="${tm_file} i386/unix.h i386/att.h dbxelf.h elfos.h newlib-stdint.h i386/i386elf.h i386/rdos.h" 48 ;; 49diff --git a/gcc/config/i386/barrelfish-scc.h b/gcc/config/i386/barrelfish-scc.h 50new file mode 100644 51index 000000000000..930451c4dcdb 52--- /dev/null 53+++ b/gcc/config/i386/barrelfish-scc.h 54@@ -0,0 +1,72 @@ 55+#define BF_SRC "{{BF_SRC}}" 56+#define BF_BUILD "{{BF_BUILD}}" 57+ 58+#undef TARGET_OS_CPP_BUILTINS 59+#define TARGET_OS_CPP_BUILTINS() \ 60+ do { \ 61+ builtin_define ("BARRELFISH"); \ 62+ builtin_define_std ("barrelfish"); \ 63+ builtin_define_std ("unix"); \ 64+ builtin_define_std ("scc"); \ 65+ builtin_define ("CONFIG_LAZY_THC"); \ 66+ builtin_define ("CONFIG_NEWLIB"); \ 67+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_LMP"); \ 68+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_UMP"); \ 69+ builtin_define ("CONFIG_FLOUNDER_BACKEND_LMP"); \ 70+ builtin_define ("CONFIG_FLOUNDER_BACKEND_UMP_IPI"); \ 71+ builtin_define ("BF_BUILD_DIR=\"" BF_BUILD "\""); \ 72+ builtin_define ("BF_SRC_DIR=\"" BF_SRC "\""); \ 73+ builtin_assert ("system=barrelfish"); \ 74+ builtin_assert ("system=unix"); \ 75+ } while(0); 76+ 77+#undef CC1_SPEC 78+#define CC1_SPEC "%(cc1_cpu) -mno-red-zone" 79+ 80+/* Default #includes are defined in 'hake/ArchDefaults.hs' (see 'cStdIncs'). */ 81+#undef CPP_SPEC 82+#define CPP_SPEC \ 83+ "-isystem" BF_SRC "/include " \ 84+ "-isystem" BF_SRC "/include/arch/scc " \ 85+ "-isystem" BF_SRC "/include/arch/x86_32 " \ 86+ "-isystem" BF_SRC "/lib/newlib/newlib/libc/include " \ 87+ "-isystem" BF_SRC "/include/c " \ 88+ "-isystem" BF_SRC "/include/target/x86_32 " \ 89+ "-isystem" BF_SRC "/include/ipv4 " \ 90+ "-isystem" BF_BUILD "/scc/include " \ 91+ "-isystem" BF_BUILD "/scc/include/dev" 92+ 93+/* Default libraries are specified in 'hake/ArchDefaults.hs' (see 'stdLibs'). 94+ Follows the order given by 'libDeps' in '{BF_SRC}/hake/RuleDefs.hs'. */ 95+#undef LIB_SPEC 96+#define LIB_SPEC \ 97+ "-L" BF_BUILD "/scc/lib " \ 98+ "-lbarrelfish " \ 99+ "-loctopus_parser " \ 100+ BF_BUILD "/scc/errors/errno.o " \ 101+ "-lnewlib " \ 102+ "-lposixcompat " \ 103+ "-lvfs " \ 104+ "-lahci " \ 105+ "-lnfs " \ 106+ "-lwip " \ 107+ "-lbarrelfish " \ 108+ "-lnewlib" 109+ 110+#undef STARTFILE_SPEC 111+#define STARTFILE_SPEC \ 112+ BF_BUILD "/scc/lib/crt0.o%s " \ 113+ BF_BUILD "/scc/lib/crtbegin.o%s" 114+ 115+#undef ENDFILE_SPEC 116+#define ENDFILE_SPEC \ 117+ "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} " \ 118+ "%{mpc32:crtprec32.o%s} " \ 119+ "%{mpc64:crtprec64.o%s} " \ 120+ "%{mpc80:crtprec80.o%s} " \ 121+ BF_BUILD "/scc/lib/crtend.o%s " \ 122+ "-lcollections" 123+ 124+/* System header files are C++ ready so don't wrap in extern "C". */ 125+#undef NO_IMPLICIT_EXTERN_C 126+#define NO_IMPLICIT_EXTERN_C 1 127diff --git a/gcc/config/i386/barrelfish-x86_32.h b/gcc/config/i386/barrelfish-x86_32.h 128new file mode 100644 129index 000000000000..84d0bf56721c 130--- /dev/null 131+++ b/gcc/config/i386/barrelfish-x86_32.h 132@@ -0,0 +1,74 @@ 133+#define BF_SRC "{{BF_SRC}}" 134+#define BF_BUILD "{{BF_BUILD}}" 135+ 136+#undef TARGET_OS_CPP_BUILTINS 137+#define TARGET_OS_CPP_BUILTINS() \ 138+ do { \ 139+ builtin_define ("BARRELFISH"); \ 140+ builtin_define_std ("barrelfish"); \ 141+ builtin_define_std ("unix"); \ 142+ builtin_define ("CONFIG_LAZY_THC"); \ 143+ builtin_define ("CONFIG_NEWLIB"); \ 144+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_LMP"); \ 145+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_UMP"); \ 146+ builtin_define ("CONFIG_FLOUNDER_BACKEND_LMP"); \ 147+ builtin_define ("CONFIG_FLOUNDER_BACKEND_UMP"); \ 148+ builtin_define ("BF_BUILD_DIR=\"" BF_BUILD "\""); \ 149+ builtin_define ("BF_SRC_DIR=\"" BF_SRC "\""); \ 150+ builtin_assert ("system=barrelfish"); \ 151+ builtin_assert ("system=unix"); \ 152+ } while(0); 153+ 154+#undef CC1_SPEC 155+#define CC1_SPEC "%(cc1_cpu) -mno-red-zone" 156+ 157+/* Default #includes are defined in 'hake/ArchDefaults.hs' (see 'cStdIncs'). */ 158+#undef CPP_SPEC 159+#define CPP_SPEC \ 160+ "-isystem" BF_SRC "/include " \ 161+ "-isystem" BF_SRC "/include/arch/x86_32 " \ 162+ "-isystem" BF_SRC "/lib/newlib/newlib/libc/include " \ 163+ "-isystem" BF_SRC "/include/c " \ 164+ "-isystem" BF_SRC "/include/target/x86_32 " \ 165+ "-isystem" BF_SRC "/lib/lwip/src/include " \ 166+ "-isystem" BF_SRC "/lib/lwip/src/include/ipv4 " \ 167+ "-isystem" BF_BUILD "/x86_32/include " \ 168+ "-isystem" BF_BUILD "/x86_32/include/dev" 169+ 170+/* Default libraries are specified in 'hake/ArchDefaults.hs' (see 'stdLibs'). 171+ Follows the order given by 'libDeps' in '{BF_SRC}/hake/RuleDefs.hs'. */ 172+#undef LIB_SPEC 173+#define LIB_SPEC \ 174+ "-L" BF_BUILD "/x86_32/lib " \ 175+ "-lbarrelfish " \ 176+ "-loctopus_parser " \ 177+ BF_BUILD "/x86_32/errors/errno.o " \ 178+ "-lnewlib " \ 179+ "-lposixcompat " \ 180+ "-lvfs " \ 181+ "-lahci " \ 182+ "-lnfs " \ 183+ "-lwip " \ 184+ "-lnet_if_raw " \ 185+ "-lbarrelfish " \ 186+ "-lterm_client " \ 187+ "-lterm_server " \ 188+ "-lnewlib" 189+ 190+#undef STARTFILE_SPEC 191+#define STARTFILE_SPEC \ 192+ BF_BUILD "/x86_32/lib/crt0.o%s " \ 193+ BF_BUILD "/x86_32/lib/crtbegin.o%s" 194+ 195+#undef ENDFILE_SPEC 196+#define ENDFILE_SPEC \ 197+ "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} " \ 198+ "%{mpc32:crtprec32.o%s} " \ 199+ "%{mpc64:crtprec64.o%s} " \ 200+ "%{mpc80:crtprec80.o%s} " \ 201+ BF_BUILD "/x86_32/lib/crtend.o%s " \ 202+ "-lcollections" 203+ 204+/* System header files are C++ ready so don't wrap in extern "C". */ 205+#undef NO_IMPLICIT_EXTERN_C 206+#define NO_IMPLICIT_EXTERN_C 1 207diff --git a/gcc/config/i386/barrelfish-x86_64.h b/gcc/config/i386/barrelfish-x86_64.h 208new file mode 100644 209index 000000000000..8608b62b1019 210--- /dev/null 211+++ b/gcc/config/i386/barrelfish-x86_64.h 212@@ -0,0 +1,74 @@ 213+#define BF_SRC "{{BF_SRC}}" 214+#define BF_BUILD "{{BF_BUILD}}" 215+ 216+#undef TARGET_OS_CPP_BUILTINS 217+#define TARGET_OS_CPP_BUILTINS() \ 218+ do { \ 219+ builtin_define ("BARRELFISH"); \ 220+ builtin_define_std ("barrelfish"); \ 221+ builtin_define_std ("unix"); \ 222+ builtin_define ("CONFIG_LAZY_THC"); \ 223+ builtin_define ("CONFIG_NEWLIB"); \ 224+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_LMP"); \ 225+ builtin_define ("CONFIG_INTERCONNECT_DRIVER_UMP"); \ 226+ builtin_define ("CONFIG_FLOUNDER_BACKEND_LMP"); \ 227+ builtin_define ("CONFIG_FLOUNDER_BACKEND_UMP"); \ 228+ builtin_define ("BF_BUILD_DIR=\"" BF_BUILD "\""); \ 229+ builtin_define ("BF_SRC_DIR=\"" BF_SRC "\""); \ 230+ builtin_assert ("system=barrelfish"); \ 231+ builtin_assert ("system=unix"); \ 232+ } while(0); 233+ 234+#undef CC1_SPEC 235+#define CC1_SPEC "%(cc1_cpu) -mno-red-zone" 236+ 237+/* Default #includes are defined in 'hake/ArchDefaults.hs' (see 'cStdIncs'). */ 238+#undef CPP_SPEC 239+#define CPP_SPEC \ 240+ "-isystem" BF_SRC "/include " \ 241+ "-isystem" BF_SRC "/include/arch/x86_64 " \ 242+ "-isystem" BF_SRC "/lib/newlib/newlib/libc/include " \ 243+ "-isystem" BF_SRC "/include/c " \ 244+ "-isystem" BF_SRC "/include/target/x86_64 " \ 245+ "-isystem" BF_SRC "/lib/lwip/src/include " \ 246+ "-isystem" BF_SRC "/lib/lwip/src/include/ipv4 " \ 247+ "-isystem" BF_BUILD "/x86_64/include " \ 248+ "-isystem" BF_BUILD "/x86_64/include/dev" 249+ 250+/* Default libraries are specified in 'hake/ArchDefaults.hs' (see 'stdLibs'). 251+ Follows the order given by 'libDeps' in '{BF_SRC}/hake/RuleDefs.hs'. */ 252+#undef LIB_SPEC 253+#define LIB_SPEC \ 254+ "-L" BF_BUILD "/x86_64/lib " \ 255+ "-lbarrelfish " \ 256+ "-loctopus_parser " \ 257+ BF_BUILD "/x86_64/errors/errno.o " \ 258+ "-lnewlib " \ 259+ "-lposixcompat " \ 260+ "-lvfs " \ 261+ "-lahci " \ 262+ "-lnfs " \ 263+ "-larranet " \ 264+ "-lnet_if_raw " \ 265+ "-lbarrelfish " \ 266+ "-lterm_client " \ 267+ "-lterm_server " \ 268+ "-lnewlib" 269+ 270+#undef STARTFILE_SPEC 271+#define STARTFILE_SPEC \ 272+ BF_BUILD "/x86_64/lib/crt0.o%s " \ 273+ BF_BUILD "/x86_64/lib/crtbegin.o%s" 274+ 275+#undef ENDFILE_SPEC 276+#define ENDFILE_SPEC \ 277+ "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s} " \ 278+ "%{mpc32:crtprec32.o%s} " \ 279+ "%{mpc64:crtprec64.o%s} " \ 280+ "%{mpc80:crtprec80.o%s} " \ 281+ BF_BUILD "/x86_64/lib/crtend.o%s " \ 282+ "-lcollections" 283+ 284+/* System header files are C++ ready so don't wrap in extern "C". */ 285+#undef NO_IMPLICIT_EXTERN_C 286+#define NO_IMPLICIT_EXTERN_C 1 287diff --git a/gcc/ginclude/stddef.h b/gcc/ginclude/stddef.h 288index b04dd659abd8..4fe4906df44e 100644 289--- a/gcc/ginclude/stddef.h 290+++ b/gcc/ginclude/stddef.h 291@@ -198,7 +198,7 @@ typedef __PTRDIFF_TYPE__ ptrdiff_t; 292 #define _GCC_SIZE_T 293 #define _SIZET_ 294 #if (defined (__FreeBSD__) && (__FreeBSD__ >= 5)) \ 295- || defined(__FreeBSD_kernel__) 296+ || defined(__FreeBSD_kernel__) || defined(__barrelfish__) 297 /* __size_t is a typedef on FreeBSD 5, must not trash it. */ 298 #elif defined (__VMS__) 299 /* __size_t is also a typedef on VMS. */ 300diff --git a/gcc/testsuite/g++.dg/dg.exp b/gcc/testsuite/g++.dg/dg.exp 301index 720135942bbf..e65f8891ef1e 100644 302--- a/gcc/testsuite/g++.dg/dg.exp 303+++ b/gcc/testsuite/g++.dg/dg.exp 304@@ -31,6 +31,7 @@ dg-init 305 # Gather a list of all tests, with the exception of those in directories 306 # that are handled specially. 307 set tests [lsort [find $srcdir/$subdir *.C]] 308+set tests [prune $tests $srcdir/$subdir/eh/*] 309 set tests [prune $tests $srcdir/$subdir/bprob/*] 310 set tests [prune $tests $srcdir/$subdir/charset/*] 311 set tests [prune $tests $srcdir/$subdir/compat/*] 312diff --git a/libgcc/config.host b/libgcc/config.host 313index 259c9a725f98..609b6a541c4f 100644 314--- a/libgcc/config.host 315+++ b/libgcc/config.host 316@@ -199,6 +199,10 @@ case ${host} in 317 tmake_file="$tmake_file t-crtstuff-pic t-libgcc-pic t-eh-dw2-dip t-slibgcc t-slibgcc-gld t-slibgcc-elf-ver t-linux" 318 extra_parts="crtbegin.o crtbeginS.o crtbeginT.o crtend.o crtendS.o" 319 ;; 320+*-*-barrelfish*) 321+ tmake_file="$tmake_file t-crtstuff-pic t-libgcc-pic t-eh-dw2-dip" 322+ extra_parts="crtbegin.o crtend.o" 323+ ;; 324 *-*-lynxos*) 325 tmake_file="$tmake_file t-lynx $cpu_type/t-crtstuff t-crtstuff-pic t-libgcc-pic" 326 extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o" 327@@ -523,6 +527,10 @@ i[34567]86-*-linux*) 328 tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 329 md_unwind_header=i386/linux-unwind.h 330 ;; 331+i[34567]86-*-barrelfish*) 332+ extra_parts="$extra_parts crtprec32.o crtprec64.o crtprec80.o crtfastmath.o" 333+ tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 334+ ;; 335 i[34567]86-*-kfreebsd*-gnu | i[34567]86-*-knetbsd*-gnu | i[34567]86-*-gnu* | i[34567]86-*-kopensolaris*-gnu) 336 extra_parts="$extra_parts crtprec32.o crtprec64.o crtprec80.o crtfastmath.o" 337 tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 338@@ -532,6 +540,10 @@ x86_64-*-linux*) 339 tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 340 md_unwind_header=i386/linux-unwind.h 341 ;; 342+x86_64-*-barrelfish*) 343+ extra_parts="$extra_parts crtprec32.o crtprec64.o crtprec80.o crtfastmath.o" 344+ tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 345+ ;; 346 x86_64-*-kfreebsd*-gnu | x86_64-*-knetbsd*-gnu) 347 extra_parts="$extra_parts crtprec32.o crtprec64.o crtprec80.o crtfastmath.o" 348 tmake_file="${tmake_file} i386/t-crtpc i386/t-crtfm i386/t-crtstuff t-dfprules" 349diff --git a/libiberty/clock.c b/libiberty/clock.c 350index 07d902e8a160..4d5817a30cf9 100644 351--- a/libiberty/clock.c 352+++ b/libiberty/clock.c 353@@ -66,7 +66,7 @@ number of seconds used. 354 355 /* FIXME: should be able to declare as clock_t. */ 356 357-long 358+clock_t 359 clock (void) 360 { 361 #ifdef HAVE_GETRUSAGE 362diff --git a/libiberty/gettimeofday.c b/libiberty/gettimeofday.c 363index fca16794028e..88f2f5ae70d3 100644 364--- a/libiberty/gettimeofday.c 365+++ b/libiberty/gettimeofday.c 366@@ -19,7 +19,7 @@ that @var{tz} be NULL. Returns 0 on success, -1 on failure. 367 */ 368 369 int 370-gettimeofday (struct timeval *tp, void *tz) 371+gettimeofday (struct timeval *tp, struct timezone *tz) 372 { 373 if (tz) 374 abort (); 375diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure 376index 57452f7fe590..1a1cfd4a6cfa 100755 377--- a/libstdc++-v3/configure 378+++ b/libstdc++-v3/configure 379@@ -52461,6 +52461,5983 @@ _ACEOF 380 fi 381 382 ;; 383+ *-barrelfish*) 384+ 385+ # All these tests are for C++; save the language and the compiler flags. 386+ # The CXXFLAGS thing is suspicious, but based on similar bits previously 387+ # found in GLIBCXX_CONFIGURE. 388+ 389+ ac_ext=cpp 390+ac_cpp='$CXXCPP $CPPFLAGS' 391+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 392+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 393+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 394+ 395+ ac_test_CXXFLAGS="${CXXFLAGS+set}" 396+ ac_save_CXXFLAGS="$CXXFLAGS" 397+ 398+ # Check for maintainer-mode bits. 399+ if test x"$USE_MAINTAINER_MODE" = xno; then 400+ WERROR='' 401+ else 402+ WERROR='-Werror' 403+ fi 404+ 405+ # Check for -ffunction-sections -fdata-sections 406+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for g++ that supports -ffunction-sections -fdata-sections" >&5 407+$as_echo_n "checking for g++ that supports -ffunction-sections -fdata-sections... " >&6; } 408+ CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections' 409+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 410+/* end confdefs.h. */ 411+int foo; void bar() { }; 412+int 413+main () 414+{ 415+ 416+ ; 417+ return 0; 418+} 419+_ACEOF 420+if ac_fn_cxx_try_compile "$LINENO"; then : 421+ ac_fdsections=yes 422+else 423+ ac_fdsections=no 424+fi 425+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 426+ if test "$ac_test_CXXFLAGS" = set; then 427+ CXXFLAGS="$ac_save_CXXFLAGS" 428+ else 429+ # this is the suspicious part 430+ CXXFLAGS='' 431+ fi 432+ if test x"$ac_fdsections" = x"yes"; then 433+ SECTION_FLAGS='-ffunction-sections -fdata-sections' 434+ fi 435+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fdsections" >&5 436+$as_echo "$ac_fdsections" >&6; } 437+ 438+ ac_ext=c 439+ac_cpp='$CPP $CPPFLAGS' 440+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 441+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 442+ac_compiler_gnu=$ac_cv_c_compiler_gnu 443+ 444+ 445+ 446+ 447+ 448+ # If we're not using GNU ld, then there's no point in even trying these 449+ # tests. Check for that first. We should have already tested for gld 450+ # by now (in libtool), but require it now just to be safe... 451+ test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS='' 452+ test -z "$OPT_LDFLAGS" && OPT_LDFLAGS='' 453+ 454+ 455+ 456+ # The name set by libtool depends on the version of libtool. Shame on us 457+ # for depending on an impl detail, but c'est la vie. Older versions used 458+ # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on 459+ # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually 460+ # makes sense). We'll test with_gnu_ld everywhere else, so if that isn't 461+ # set (hence we're using an older libtool), then set it. 462+ if test x${with_gnu_ld+set} != xset; then 463+ if test x${ac_cv_prog_gnu_ld+set} != xset; then 464+ # We got through "ac_require(ac_prog_ld)" and still not set? Huh? 465+ with_gnu_ld=no 466+ else 467+ with_gnu_ld=$ac_cv_prog_gnu_ld 468+ fi 469+ fi 470+ 471+ # Start by getting the version number. I think the libtool test already 472+ # does some of this, but throws away the result. 473+ glibcxx_ld_is_gold=no 474+ if test x"$with_gnu_ld" = x"yes"; then 475+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld version" >&5 476+$as_echo_n "checking for ld version... " >&6; } 477+ 478+ if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then 479+ glibcxx_ld_is_gold=yes 480+ fi 481+ ldver=`$LD --version 2>/dev/null | 482+ sed -e 's/GNU gold /GNU ld /;s/GNU ld version /GNU ld /;s/GNU ld ([^)]*) /GNU ld /;s/GNU ld \([0-9.][0-9.]*\).*/\1/; q'` 483+ 484+ glibcxx_gnu_ld_version=`echo $ldver | \ 485+ $AWK -F. '{ if (NF<3) $3=0; print ($1*100+$2)*100+$3 }'` 486+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_gnu_ld_version" >&5 487+$as_echo "$glibcxx_gnu_ld_version" >&6; } 488+ fi 489+ 490+ # Set --gc-sections. 491+ glibcxx_have_gc_sections=no 492+ if test "$glibcxx_ld_is_gold" = "yes"; then 493+ if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then 494+ glibcxx_have_gc_sections=yes 495+ fi 496+ else 497+ glibcxx_gcsections_min_ld=21602 498+ if test x"$with_gnu_ld" = x"yes" && 499+ test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then 500+ glibcxx_have_gc_sections=yes 501+ fi 502+ fi 503+ if test "$glibcxx_have_gc_sections" = "yes"; then 504+ # Sufficiently young GNU ld it is! Joy and bunny rabbits! 505+ # NB: This flag only works reliably after 2.16.1. Configure tests 506+ # for this are difficult, so hard wire a value that should work. 507+ 508+ ac_test_CFLAGS="${CFLAGS+set}" 509+ ac_save_CFLAGS="$CFLAGS" 510+ CFLAGS='-Wl,--gc-sections' 511+ 512+ # Check for -Wl,--gc-sections 513+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld that supports -Wl,--gc-sections" >&5 514+$as_echo_n "checking for ld that supports -Wl,--gc-sections... " >&6; } 515+ if test x$gcc_no_link = xyes; then 516+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 517+fi 518+cat confdefs.h - <<_ACEOF >conftest.$ac_ext 519+/* end confdefs.h. */ 520+ int one(void) { return 1; } 521+ int two(void) { return 2; } 522+ 523+int 524+main () 525+{ 526+ two(); 527+ ; 528+ return 0; 529+} 530+_ACEOF 531+if ac_fn_c_try_link "$LINENO"; then : 532+ ac_gcsections=yes 533+else 534+ ac_gcsections=no 535+fi 536+rm -f core conftest.err conftest.$ac_objext \ 537+ conftest$ac_exeext conftest.$ac_ext 538+ if test "$ac_gcsections" = "yes"; then 539+ rm -f conftest.c 540+ touch conftest.c 541+ if $CC -c conftest.c; then 542+ if $LD --gc-sections -o conftest conftest.o 2>&1 | \ 543+ grep "Warning: gc-sections option ignored" > /dev/null; then 544+ ac_gcsections=no 545+ fi 546+ fi 547+ rm -f conftest.c conftest.o conftest 548+ fi 549+ if test "$ac_gcsections" = "yes"; then 550+ SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS" 551+ fi 552+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_gcsections" >&5 553+$as_echo "$ac_gcsections" >&6; } 554+ 555+ if test "$ac_test_CFLAGS" = set; then 556+ CFLAGS="$ac_save_CFLAGS" 557+ else 558+ # this is the suspicious part 559+ CFLAGS='' 560+ fi 561+ fi 562+ 563+ # Set -z,relro. 564+ # Note this is only for shared objects. 565+ ac_ld_relro=no 566+ if test x"$with_gnu_ld" = x"yes"; then 567+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld that supports -Wl,-z,relro" >&5 568+$as_echo_n "checking for ld that supports -Wl,-z,relro... " >&6; } 569+ cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"` 570+ if test -n "$cxx_z_relo"; then 571+ OPT_LDFLAGS="-Wl,-z,relro" 572+ ac_ld_relro=yes 573+ fi 574+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ld_relro" >&5 575+$as_echo "$ac_ld_relro" >&6; } 576+ fi 577+ 578+ # Set linker optimization flags. 579+ if test x"$with_gnu_ld" = x"yes"; then 580+ OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS" 581+ fi 582+ 583+ 584+ 585+ 586+ 587+ ac_test_CXXFLAGS="${CXXFLAGS+set}" 588+ ac_save_CXXFLAGS="$CXXFLAGS" 589+ CXXFLAGS='-fno-builtin -D_GNU_SOURCE' 590+ 591+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sin in -lm" >&5 592+$as_echo_n "checking for sin in -lm... " >&6; } 593+if test "${ac_cv_lib_m_sin+set}" = set; then : 594+ $as_echo_n "(cached) " >&6 595+else 596+ ac_check_lib_save_LIBS=$LIBS 597+LIBS="-lm $LIBS" 598+if test x$gcc_no_link = xyes; then 599+ as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 600+fi 601+cat confdefs.h - <<_ACEOF >conftest.$ac_ext 602+/* end confdefs.h. */ 603+ 604+/* Override any GCC internal prototype to avoid an error. 605+ Use char because int might match the return type of a GCC 606+ builtin and then its argument prototype would still apply. */ 607+#ifdef __cplusplus 608+extern "C" 609+#endif 610+char sin (); 611+int 612+main () 613+{ 614+return sin (); 615+ ; 616+ return 0; 617+} 618+_ACEOF 619+if ac_fn_c_try_link "$LINENO"; then : 620+ ac_cv_lib_m_sin=yes 621+else 622+ ac_cv_lib_m_sin=no 623+fi 624+rm -f core conftest.err conftest.$ac_objext \ 625+ conftest$ac_exeext conftest.$ac_ext 626+LIBS=$ac_check_lib_save_LIBS 627+fi 628+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_sin" >&5 629+$as_echo "$ac_cv_lib_m_sin" >&6; } 630+if test "x$ac_cv_lib_m_sin" = x""yes; then : 631+ libm="-lm" 632+fi 633+ 634+ ac_save_LIBS="$LIBS" 635+ LIBS="$LIBS $libm" 636+ 637+ 638+ 639+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isinf declaration" >&5 640+$as_echo_n "checking for isinf declaration... " >&6; } 641+ if test x${glibcxx_cv_func_isinf_use+set} != xset; then 642+ if test "${glibcxx_cv_func_isinf_use+set}" = set; then : 643+ $as_echo_n "(cached) " >&6 644+else 645+ 646+ 647+ ac_ext=cpp 648+ac_cpp='$CXXCPP $CPPFLAGS' 649+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 650+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 651+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 652+ 653+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 654+/* end confdefs.h. */ 655+#include <math.h> 656+ #ifdef HAVE_IEEEFP_H 657+ #include <ieeefp.h> 658+ #endif 659+ 660+int 661+main () 662+{ 663+ isinf(0); 664+ ; 665+ return 0; 666+} 667+_ACEOF 668+if ac_fn_cxx_try_compile "$LINENO"; then : 669+ glibcxx_cv_func_isinf_use=yes 670+else 671+ glibcxx_cv_func_isinf_use=no 672+fi 673+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 674+ ac_ext=c 675+ac_cpp='$CPP $CPPFLAGS' 676+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 677+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 678+ac_compiler_gnu=$ac_cv_c_compiler_gnu 679+ 680+ 681+fi 682+ 683+ fi 684+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isinf_use" >&5 685+$as_echo "$glibcxx_cv_func_isinf_use" >&6; } 686+ 687+ if test x$glibcxx_cv_func_isinf_use = x"yes"; then 688+ for ac_func in isinf 689+do : 690+ ac_fn_c_check_func "$LINENO" "isinf" "ac_cv_func_isinf" 691+if test "x$ac_cv_func_isinf" = x""yes; then : 692+ cat >>confdefs.h <<_ACEOF 693+#define HAVE_ISINF 1 694+_ACEOF 695+ 696+fi 697+done 698+ 699+ else 700+ 701+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isinf declaration" >&5 702+$as_echo_n "checking for _isinf declaration... " >&6; } 703+ if test x${glibcxx_cv_func__isinf_use+set} != xset; then 704+ if test "${glibcxx_cv_func__isinf_use+set}" = set; then : 705+ $as_echo_n "(cached) " >&6 706+else 707+ 708+ 709+ ac_ext=cpp 710+ac_cpp='$CXXCPP $CPPFLAGS' 711+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 712+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 713+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 714+ 715+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 716+/* end confdefs.h. */ 717+#include <math.h> 718+ #ifdef HAVE_IEEEFP_H 719+ #include <ieeefp.h> 720+ #endif 721+ 722+int 723+main () 724+{ 725+ _isinf(0); 726+ ; 727+ return 0; 728+} 729+_ACEOF 730+if ac_fn_cxx_try_compile "$LINENO"; then : 731+ glibcxx_cv_func__isinf_use=yes 732+else 733+ glibcxx_cv_func__isinf_use=no 734+fi 735+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 736+ ac_ext=c 737+ac_cpp='$CPP $CPPFLAGS' 738+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 739+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 740+ac_compiler_gnu=$ac_cv_c_compiler_gnu 741+ 742+ 743+fi 744+ 745+ fi 746+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isinf_use" >&5 747+$as_echo "$glibcxx_cv_func__isinf_use" >&6; } 748+ 749+ if test x$glibcxx_cv_func__isinf_use = x"yes"; then 750+ for ac_func in _isinf 751+do : 752+ ac_fn_c_check_func "$LINENO" "_isinf" "ac_cv_func__isinf" 753+if test "x$ac_cv_func__isinf" = x""yes; then : 754+ cat >>confdefs.h <<_ACEOF 755+#define HAVE__ISINF 1 756+_ACEOF 757+ 758+fi 759+done 760+ 761+ fi 762+ fi 763+ 764+ 765+ 766+ 767+ 768+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isnan declaration" >&5 769+$as_echo_n "checking for isnan declaration... " >&6; } 770+ if test x${glibcxx_cv_func_isnan_use+set} != xset; then 771+ if test "${glibcxx_cv_func_isnan_use+set}" = set; then : 772+ $as_echo_n "(cached) " >&6 773+else 774+ 775+ 776+ ac_ext=cpp 777+ac_cpp='$CXXCPP $CPPFLAGS' 778+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 779+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 780+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 781+ 782+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 783+/* end confdefs.h. */ 784+#include <math.h> 785+ #ifdef HAVE_IEEEFP_H 786+ #include <ieeefp.h> 787+ #endif 788+ 789+int 790+main () 791+{ 792+ isnan(0); 793+ ; 794+ return 0; 795+} 796+_ACEOF 797+if ac_fn_cxx_try_compile "$LINENO"; then : 798+ glibcxx_cv_func_isnan_use=yes 799+else 800+ glibcxx_cv_func_isnan_use=no 801+fi 802+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 803+ ac_ext=c 804+ac_cpp='$CPP $CPPFLAGS' 805+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 806+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 807+ac_compiler_gnu=$ac_cv_c_compiler_gnu 808+ 809+ 810+fi 811+ 812+ fi 813+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isnan_use" >&5 814+$as_echo "$glibcxx_cv_func_isnan_use" >&6; } 815+ 816+ if test x$glibcxx_cv_func_isnan_use = x"yes"; then 817+ for ac_func in isnan 818+do : 819+ ac_fn_c_check_func "$LINENO" "isnan" "ac_cv_func_isnan" 820+if test "x$ac_cv_func_isnan" = x""yes; then : 821+ cat >>confdefs.h <<_ACEOF 822+#define HAVE_ISNAN 1 823+_ACEOF 824+ 825+fi 826+done 827+ 828+ else 829+ 830+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isnan declaration" >&5 831+$as_echo_n "checking for _isnan declaration... " >&6; } 832+ if test x${glibcxx_cv_func__isnan_use+set} != xset; then 833+ if test "${glibcxx_cv_func__isnan_use+set}" = set; then : 834+ $as_echo_n "(cached) " >&6 835+else 836+ 837+ 838+ ac_ext=cpp 839+ac_cpp='$CXXCPP $CPPFLAGS' 840+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 841+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 842+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 843+ 844+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 845+/* end confdefs.h. */ 846+#include <math.h> 847+ #ifdef HAVE_IEEEFP_H 848+ #include <ieeefp.h> 849+ #endif 850+ 851+int 852+main () 853+{ 854+ _isnan(0); 855+ ; 856+ return 0; 857+} 858+_ACEOF 859+if ac_fn_cxx_try_compile "$LINENO"; then : 860+ glibcxx_cv_func__isnan_use=yes 861+else 862+ glibcxx_cv_func__isnan_use=no 863+fi 864+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 865+ ac_ext=c 866+ac_cpp='$CPP $CPPFLAGS' 867+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 868+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 869+ac_compiler_gnu=$ac_cv_c_compiler_gnu 870+ 871+ 872+fi 873+ 874+ fi 875+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isnan_use" >&5 876+$as_echo "$glibcxx_cv_func__isnan_use" >&6; } 877+ 878+ if test x$glibcxx_cv_func__isnan_use = x"yes"; then 879+ for ac_func in _isnan 880+do : 881+ ac_fn_c_check_func "$LINENO" "_isnan" "ac_cv_func__isnan" 882+if test "x$ac_cv_func__isnan" = x""yes; then : 883+ cat >>confdefs.h <<_ACEOF 884+#define HAVE__ISNAN 1 885+_ACEOF 886+ 887+fi 888+done 889+ 890+ fi 891+ fi 892+ 893+ 894+ 895+ 896+ 897+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for finite declaration" >&5 898+$as_echo_n "checking for finite declaration... " >&6; } 899+ if test x${glibcxx_cv_func_finite_use+set} != xset; then 900+ if test "${glibcxx_cv_func_finite_use+set}" = set; then : 901+ $as_echo_n "(cached) " >&6 902+else 903+ 904+ 905+ ac_ext=cpp 906+ac_cpp='$CXXCPP $CPPFLAGS' 907+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 908+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 909+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 910+ 911+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 912+/* end confdefs.h. */ 913+#include <math.h> 914+ #ifdef HAVE_IEEEFP_H 915+ #include <ieeefp.h> 916+ #endif 917+ 918+int 919+main () 920+{ 921+ finite(0); 922+ ; 923+ return 0; 924+} 925+_ACEOF 926+if ac_fn_cxx_try_compile "$LINENO"; then : 927+ glibcxx_cv_func_finite_use=yes 928+else 929+ glibcxx_cv_func_finite_use=no 930+fi 931+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 932+ ac_ext=c 933+ac_cpp='$CPP $CPPFLAGS' 934+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 935+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 936+ac_compiler_gnu=$ac_cv_c_compiler_gnu 937+ 938+ 939+fi 940+ 941+ fi 942+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_finite_use" >&5 943+$as_echo "$glibcxx_cv_func_finite_use" >&6; } 944+ 945+ if test x$glibcxx_cv_func_finite_use = x"yes"; then 946+ for ac_func in finite 947+do : 948+ ac_fn_c_check_func "$LINENO" "finite" "ac_cv_func_finite" 949+if test "x$ac_cv_func_finite" = x""yes; then : 950+ cat >>confdefs.h <<_ACEOF 951+#define HAVE_FINITE 1 952+_ACEOF 953+ 954+fi 955+done 956+ 957+ else 958+ 959+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _finite declaration" >&5 960+$as_echo_n "checking for _finite declaration... " >&6; } 961+ if test x${glibcxx_cv_func__finite_use+set} != xset; then 962+ if test "${glibcxx_cv_func__finite_use+set}" = set; then : 963+ $as_echo_n "(cached) " >&6 964+else 965+ 966+ 967+ ac_ext=cpp 968+ac_cpp='$CXXCPP $CPPFLAGS' 969+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 970+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 971+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 972+ 973+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 974+/* end confdefs.h. */ 975+#include <math.h> 976+ #ifdef HAVE_IEEEFP_H 977+ #include <ieeefp.h> 978+ #endif 979+ 980+int 981+main () 982+{ 983+ _finite(0); 984+ ; 985+ return 0; 986+} 987+_ACEOF 988+if ac_fn_cxx_try_compile "$LINENO"; then : 989+ glibcxx_cv_func__finite_use=yes 990+else 991+ glibcxx_cv_func__finite_use=no 992+fi 993+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 994+ ac_ext=c 995+ac_cpp='$CPP $CPPFLAGS' 996+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 997+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 998+ac_compiler_gnu=$ac_cv_c_compiler_gnu 999+ 1000+ 1001+fi 1002+ 1003+ fi 1004+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__finite_use" >&5 1005+$as_echo "$glibcxx_cv_func__finite_use" >&6; } 1006+ 1007+ if test x$glibcxx_cv_func__finite_use = x"yes"; then 1008+ for ac_func in _finite 1009+do : 1010+ ac_fn_c_check_func "$LINENO" "_finite" "ac_cv_func__finite" 1011+if test "x$ac_cv_func__finite" = x""yes; then : 1012+ cat >>confdefs.h <<_ACEOF 1013+#define HAVE__FINITE 1 1014+_ACEOF 1015+ 1016+fi 1017+done 1018+ 1019+ fi 1020+ fi 1021+ 1022+ 1023+ 1024+ 1025+ 1026+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sincos declaration" >&5 1027+$as_echo_n "checking for sincos declaration... " >&6; } 1028+ if test x${glibcxx_cv_func_sincos_use+set} != xset; then 1029+ if test "${glibcxx_cv_func_sincos_use+set}" = set; then : 1030+ $as_echo_n "(cached) " >&6 1031+else 1032+ 1033+ 1034+ ac_ext=cpp 1035+ac_cpp='$CXXCPP $CPPFLAGS' 1036+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1037+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1038+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1039+ 1040+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1041+/* end confdefs.h. */ 1042+#include <math.h> 1043+int 1044+main () 1045+{ 1046+ sincos(0, 0, 0); 1047+ ; 1048+ return 0; 1049+} 1050+_ACEOF 1051+if ac_fn_cxx_try_compile "$LINENO"; then : 1052+ glibcxx_cv_func_sincos_use=yes 1053+else 1054+ glibcxx_cv_func_sincos_use=no 1055+fi 1056+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1057+ ac_ext=c 1058+ac_cpp='$CPP $CPPFLAGS' 1059+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1060+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1061+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1062+ 1063+ 1064+fi 1065+ 1066+ fi 1067+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_sincos_use" >&5 1068+$as_echo "$glibcxx_cv_func_sincos_use" >&6; } 1069+ 1070+ if test x$glibcxx_cv_func_sincos_use = x"yes"; then 1071+ for ac_func in sincos 1072+do : 1073+ ac_fn_c_check_func "$LINENO" "sincos" "ac_cv_func_sincos" 1074+if test "x$ac_cv_func_sincos" = x""yes; then : 1075+ cat >>confdefs.h <<_ACEOF 1076+#define HAVE_SINCOS 1 1077+_ACEOF 1078+ 1079+fi 1080+done 1081+ 1082+ else 1083+ 1084+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _sincos declaration" >&5 1085+$as_echo_n "checking for _sincos declaration... " >&6; } 1086+ if test x${glibcxx_cv_func__sincos_use+set} != xset; then 1087+ if test "${glibcxx_cv_func__sincos_use+set}" = set; then : 1088+ $as_echo_n "(cached) " >&6 1089+else 1090+ 1091+ 1092+ ac_ext=cpp 1093+ac_cpp='$CXXCPP $CPPFLAGS' 1094+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1095+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1096+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1097+ 1098+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1099+/* end confdefs.h. */ 1100+#include <math.h> 1101+int 1102+main () 1103+{ 1104+ _sincos(0, 0, 0); 1105+ ; 1106+ return 0; 1107+} 1108+_ACEOF 1109+if ac_fn_cxx_try_compile "$LINENO"; then : 1110+ glibcxx_cv_func__sincos_use=yes 1111+else 1112+ glibcxx_cv_func__sincos_use=no 1113+fi 1114+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1115+ ac_ext=c 1116+ac_cpp='$CPP $CPPFLAGS' 1117+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1118+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1119+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1120+ 1121+ 1122+fi 1123+ 1124+ fi 1125+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__sincos_use" >&5 1126+$as_echo "$glibcxx_cv_func__sincos_use" >&6; } 1127+ 1128+ if test x$glibcxx_cv_func__sincos_use = x"yes"; then 1129+ for ac_func in _sincos 1130+do : 1131+ ac_fn_c_check_func "$LINENO" "_sincos" "ac_cv_func__sincos" 1132+if test "x$ac_cv_func__sincos" = x""yes; then : 1133+ cat >>confdefs.h <<_ACEOF 1134+#define HAVE__SINCOS 1 1135+_ACEOF 1136+ 1137+fi 1138+done 1139+ 1140+ fi 1141+ fi 1142+ 1143+ 1144+ 1145+ 1146+ 1147+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fpclass declaration" >&5 1148+$as_echo_n "checking for fpclass declaration... " >&6; } 1149+ if test x${glibcxx_cv_func_fpclass_use+set} != xset; then 1150+ if test "${glibcxx_cv_func_fpclass_use+set}" = set; then : 1151+ $as_echo_n "(cached) " >&6 1152+else 1153+ 1154+ 1155+ ac_ext=cpp 1156+ac_cpp='$CXXCPP $CPPFLAGS' 1157+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1158+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1159+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1160+ 1161+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1162+/* end confdefs.h. */ 1163+#include <math.h> 1164+ #ifdef HAVE_IEEEFP_H 1165+ #include <ieeefp.h> 1166+ #endif 1167+ 1168+int 1169+main () 1170+{ 1171+ fpclass(0); 1172+ ; 1173+ return 0; 1174+} 1175+_ACEOF 1176+if ac_fn_cxx_try_compile "$LINENO"; then : 1177+ glibcxx_cv_func_fpclass_use=yes 1178+else 1179+ glibcxx_cv_func_fpclass_use=no 1180+fi 1181+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1182+ ac_ext=c 1183+ac_cpp='$CPP $CPPFLAGS' 1184+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1185+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1186+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1187+ 1188+ 1189+fi 1190+ 1191+ fi 1192+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_fpclass_use" >&5 1193+$as_echo "$glibcxx_cv_func_fpclass_use" >&6; } 1194+ 1195+ if test x$glibcxx_cv_func_fpclass_use = x"yes"; then 1196+ for ac_func in fpclass 1197+do : 1198+ ac_fn_c_check_func "$LINENO" "fpclass" "ac_cv_func_fpclass" 1199+if test "x$ac_cv_func_fpclass" = x""yes; then : 1200+ cat >>confdefs.h <<_ACEOF 1201+#define HAVE_FPCLASS 1 1202+_ACEOF 1203+ 1204+fi 1205+done 1206+ 1207+ else 1208+ 1209+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _fpclass declaration" >&5 1210+$as_echo_n "checking for _fpclass declaration... " >&6; } 1211+ if test x${glibcxx_cv_func__fpclass_use+set} != xset; then 1212+ if test "${glibcxx_cv_func__fpclass_use+set}" = set; then : 1213+ $as_echo_n "(cached) " >&6 1214+else 1215+ 1216+ 1217+ ac_ext=cpp 1218+ac_cpp='$CXXCPP $CPPFLAGS' 1219+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1220+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1221+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1222+ 1223+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1224+/* end confdefs.h. */ 1225+#include <math.h> 1226+ #ifdef HAVE_IEEEFP_H 1227+ #include <ieeefp.h> 1228+ #endif 1229+ 1230+int 1231+main () 1232+{ 1233+ _fpclass(0); 1234+ ; 1235+ return 0; 1236+} 1237+_ACEOF 1238+if ac_fn_cxx_try_compile "$LINENO"; then : 1239+ glibcxx_cv_func__fpclass_use=yes 1240+else 1241+ glibcxx_cv_func__fpclass_use=no 1242+fi 1243+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1244+ ac_ext=c 1245+ac_cpp='$CPP $CPPFLAGS' 1246+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1247+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1248+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1249+ 1250+ 1251+fi 1252+ 1253+ fi 1254+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__fpclass_use" >&5 1255+$as_echo "$glibcxx_cv_func__fpclass_use" >&6; } 1256+ 1257+ if test x$glibcxx_cv_func__fpclass_use = x"yes"; then 1258+ for ac_func in _fpclass 1259+do : 1260+ ac_fn_c_check_func "$LINENO" "_fpclass" "ac_cv_func__fpclass" 1261+if test "x$ac_cv_func__fpclass" = x""yes; then : 1262+ cat >>confdefs.h <<_ACEOF 1263+#define HAVE__FPCLASS 1 1264+_ACEOF 1265+ 1266+fi 1267+done 1268+ 1269+ fi 1270+ fi 1271+ 1272+ 1273+ 1274+ 1275+ 1276+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qfpclass declaration" >&5 1277+$as_echo_n "checking for qfpclass declaration... " >&6; } 1278+ if test x${glibcxx_cv_func_qfpclass_use+set} != xset; then 1279+ if test "${glibcxx_cv_func_qfpclass_use+set}" = set; then : 1280+ $as_echo_n "(cached) " >&6 1281+else 1282+ 1283+ 1284+ ac_ext=cpp 1285+ac_cpp='$CXXCPP $CPPFLAGS' 1286+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1287+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1288+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1289+ 1290+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1291+/* end confdefs.h. */ 1292+#include <math.h> 1293+ #ifdef HAVE_IEEEFP_H 1294+ #include <ieeefp.h> 1295+ #endif 1296+ 1297+int 1298+main () 1299+{ 1300+ qfpclass(0); 1301+ ; 1302+ return 0; 1303+} 1304+_ACEOF 1305+if ac_fn_cxx_try_compile "$LINENO"; then : 1306+ glibcxx_cv_func_qfpclass_use=yes 1307+else 1308+ glibcxx_cv_func_qfpclass_use=no 1309+fi 1310+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1311+ ac_ext=c 1312+ac_cpp='$CPP $CPPFLAGS' 1313+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1314+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1315+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1316+ 1317+ 1318+fi 1319+ 1320+ fi 1321+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_qfpclass_use" >&5 1322+$as_echo "$glibcxx_cv_func_qfpclass_use" >&6; } 1323+ 1324+ if test x$glibcxx_cv_func_qfpclass_use = x"yes"; then 1325+ for ac_func in qfpclass 1326+do : 1327+ ac_fn_c_check_func "$LINENO" "qfpclass" "ac_cv_func_qfpclass" 1328+if test "x$ac_cv_func_qfpclass" = x""yes; then : 1329+ cat >>confdefs.h <<_ACEOF 1330+#define HAVE_QFPCLASS 1 1331+_ACEOF 1332+ 1333+fi 1334+done 1335+ 1336+ else 1337+ 1338+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _qfpclass declaration" >&5 1339+$as_echo_n "checking for _qfpclass declaration... " >&6; } 1340+ if test x${glibcxx_cv_func__qfpclass_use+set} != xset; then 1341+ if test "${glibcxx_cv_func__qfpclass_use+set}" = set; then : 1342+ $as_echo_n "(cached) " >&6 1343+else 1344+ 1345+ 1346+ ac_ext=cpp 1347+ac_cpp='$CXXCPP $CPPFLAGS' 1348+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1349+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1350+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1351+ 1352+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1353+/* end confdefs.h. */ 1354+#include <math.h> 1355+ #ifdef HAVE_IEEEFP_H 1356+ #include <ieeefp.h> 1357+ #endif 1358+ 1359+int 1360+main () 1361+{ 1362+ _qfpclass(0); 1363+ ; 1364+ return 0; 1365+} 1366+_ACEOF 1367+if ac_fn_cxx_try_compile "$LINENO"; then : 1368+ glibcxx_cv_func__qfpclass_use=yes 1369+else 1370+ glibcxx_cv_func__qfpclass_use=no 1371+fi 1372+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1373+ ac_ext=c 1374+ac_cpp='$CPP $CPPFLAGS' 1375+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1376+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1377+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1378+ 1379+ 1380+fi 1381+ 1382+ fi 1383+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__qfpclass_use" >&5 1384+$as_echo "$glibcxx_cv_func__qfpclass_use" >&6; } 1385+ 1386+ if test x$glibcxx_cv_func__qfpclass_use = x"yes"; then 1387+ for ac_func in _qfpclass 1388+do : 1389+ ac_fn_c_check_func "$LINENO" "_qfpclass" "ac_cv_func__qfpclass" 1390+if test "x$ac_cv_func__qfpclass" = x""yes; then : 1391+ cat >>confdefs.h <<_ACEOF 1392+#define HAVE__QFPCLASS 1 1393+_ACEOF 1394+ 1395+fi 1396+done 1397+ 1398+ fi 1399+ fi 1400+ 1401+ 1402+ 1403+ 1404+ 1405+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hypot declaration" >&5 1406+$as_echo_n "checking for hypot declaration... " >&6; } 1407+ if test x${glibcxx_cv_func_hypot_use+set} != xset; then 1408+ if test "${glibcxx_cv_func_hypot_use+set}" = set; then : 1409+ $as_echo_n "(cached) " >&6 1410+else 1411+ 1412+ 1413+ ac_ext=cpp 1414+ac_cpp='$CXXCPP $CPPFLAGS' 1415+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1416+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1417+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1418+ 1419+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1420+/* end confdefs.h. */ 1421+#include <math.h> 1422+int 1423+main () 1424+{ 1425+ hypot(0, 0); 1426+ ; 1427+ return 0; 1428+} 1429+_ACEOF 1430+if ac_fn_cxx_try_compile "$LINENO"; then : 1431+ glibcxx_cv_func_hypot_use=yes 1432+else 1433+ glibcxx_cv_func_hypot_use=no 1434+fi 1435+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1436+ ac_ext=c 1437+ac_cpp='$CPP $CPPFLAGS' 1438+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1439+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1440+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1441+ 1442+ 1443+fi 1444+ 1445+ fi 1446+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_hypot_use" >&5 1447+$as_echo "$glibcxx_cv_func_hypot_use" >&6; } 1448+ 1449+ if test x$glibcxx_cv_func_hypot_use = x"yes"; then 1450+ for ac_func in hypot 1451+do : 1452+ ac_fn_c_check_func "$LINENO" "hypot" "ac_cv_func_hypot" 1453+if test "x$ac_cv_func_hypot" = x""yes; then : 1454+ cat >>confdefs.h <<_ACEOF 1455+#define HAVE_HYPOT 1 1456+_ACEOF 1457+ 1458+fi 1459+done 1460+ 1461+ else 1462+ 1463+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _hypot declaration" >&5 1464+$as_echo_n "checking for _hypot declaration... " >&6; } 1465+ if test x${glibcxx_cv_func__hypot_use+set} != xset; then 1466+ if test "${glibcxx_cv_func__hypot_use+set}" = set; then : 1467+ $as_echo_n "(cached) " >&6 1468+else 1469+ 1470+ 1471+ ac_ext=cpp 1472+ac_cpp='$CXXCPP $CPPFLAGS' 1473+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1474+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1475+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1476+ 1477+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1478+/* end confdefs.h. */ 1479+#include <math.h> 1480+int 1481+main () 1482+{ 1483+ _hypot(0, 0); 1484+ ; 1485+ return 0; 1486+} 1487+_ACEOF 1488+if ac_fn_cxx_try_compile "$LINENO"; then : 1489+ glibcxx_cv_func__hypot_use=yes 1490+else 1491+ glibcxx_cv_func__hypot_use=no 1492+fi 1493+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1494+ ac_ext=c 1495+ac_cpp='$CPP $CPPFLAGS' 1496+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1497+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1498+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1499+ 1500+ 1501+fi 1502+ 1503+ fi 1504+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__hypot_use" >&5 1505+$as_echo "$glibcxx_cv_func__hypot_use" >&6; } 1506+ 1507+ if test x$glibcxx_cv_func__hypot_use = x"yes"; then 1508+ for ac_func in _hypot 1509+do : 1510+ ac_fn_c_check_func "$LINENO" "_hypot" "ac_cv_func__hypot" 1511+if test "x$ac_cv_func__hypot" = x""yes; then : 1512+ cat >>confdefs.h <<_ACEOF 1513+#define HAVE__HYPOT 1 1514+_ACEOF 1515+ 1516+fi 1517+done 1518+ 1519+ fi 1520+ fi 1521+ 1522+ 1523+ 1524+ 1525+ 1526+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for float trig functions" >&5 1527+$as_echo_n "checking for float trig functions... " >&6; } 1528+ if test "${glibcxx_cv_func_float_trig_use+set}" = set; then : 1529+ $as_echo_n "(cached) " >&6 1530+else 1531+ 1532+ 1533+ ac_ext=cpp 1534+ac_cpp='$CXXCPP $CPPFLAGS' 1535+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1536+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1537+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1538+ 1539+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1540+/* end confdefs.h. */ 1541+#include <math.h> 1542+int 1543+main () 1544+{ 1545+acosf (0); asinf (0); atanf (0); cosf (0); sinf (0); tanf (0); coshf (0); sinhf (0); tanhf (0); 1546+ ; 1547+ return 0; 1548+} 1549+_ACEOF 1550+if ac_fn_cxx_try_compile "$LINENO"; then : 1551+ glibcxx_cv_func_float_trig_use=yes 1552+else 1553+ glibcxx_cv_func_float_trig_use=no 1554+fi 1555+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1556+ ac_ext=c 1557+ac_cpp='$CPP $CPPFLAGS' 1558+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1559+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1560+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1561+ 1562+fi 1563+ 1564+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_float_trig_use" >&5 1565+$as_echo "$glibcxx_cv_func_float_trig_use" >&6; } 1566+ if test x$glibcxx_cv_func_float_trig_use = x"yes"; then 1567+ for ac_func in acosf asinf atanf cosf sinf tanf coshf sinhf tanhf 1568+do : 1569+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 1570+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 1571+eval as_val=\$$as_ac_var 1572+ if test "x$as_val" = x""yes; then : 1573+ cat >>confdefs.h <<_ACEOF 1574+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 1575+_ACEOF 1576+ 1577+fi 1578+done 1579+ 1580+ else 1581+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _float trig functions" >&5 1582+$as_echo_n "checking for _float trig functions... " >&6; } 1583+ if test "${glibcxx_cv_func__float_trig_use+set}" = set; then : 1584+ $as_echo_n "(cached) " >&6 1585+else 1586+ 1587+ 1588+ ac_ext=cpp 1589+ac_cpp='$CXXCPP $CPPFLAGS' 1590+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1591+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1592+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1593+ 1594+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1595+/* end confdefs.h. */ 1596+#include <math.h> 1597+int 1598+main () 1599+{ 1600+_acosf (0); _asinf (0); _atanf (0); _cosf (0); _sinf (0); _tanf (0); _coshf (0); _sinhf (0); _tanhf (0); 1601+ ; 1602+ return 0; 1603+} 1604+_ACEOF 1605+if ac_fn_cxx_try_compile "$LINENO"; then : 1606+ glibcxx_cv_func__float_trig_use=yes 1607+else 1608+ glibcxx_cv_func__float_trig_use=no 1609+fi 1610+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1611+ ac_ext=c 1612+ac_cpp='$CPP $CPPFLAGS' 1613+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1614+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1615+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1616+ 1617+fi 1618+ 1619+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__float_trig_use" >&5 1620+$as_echo "$glibcxx_cv_func__float_trig_use" >&6; } 1621+ if test x$glibcxx_cv_func__float_trig_use = x"yes"; then 1622+ for ac_func in _acosf _asinf _atanf _cosf _sinf _tanf _coshf _sinhf _tanhf 1623+do : 1624+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 1625+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 1626+eval as_val=\$$as_ac_var 1627+ if test "x$as_val" = x""yes; then : 1628+ cat >>confdefs.h <<_ACEOF 1629+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 1630+_ACEOF 1631+ 1632+fi 1633+done 1634+ 1635+ fi 1636+ fi 1637+ 1638+ 1639+ 1640+ 1641+ 1642+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for float round functions" >&5 1643+$as_echo_n "checking for float round functions... " >&6; } 1644+ if test "${glibcxx_cv_func_float_round_use+set}" = set; then : 1645+ $as_echo_n "(cached) " >&6 1646+else 1647+ 1648+ 1649+ ac_ext=cpp 1650+ac_cpp='$CXXCPP $CPPFLAGS' 1651+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1652+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1653+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1654+ 1655+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1656+/* end confdefs.h. */ 1657+#include <math.h> 1658+int 1659+main () 1660+{ 1661+ceilf (0); floorf (0); 1662+ ; 1663+ return 0; 1664+} 1665+_ACEOF 1666+if ac_fn_cxx_try_compile "$LINENO"; then : 1667+ glibcxx_cv_func_float_round_use=yes 1668+else 1669+ glibcxx_cv_func_float_round_use=no 1670+fi 1671+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1672+ ac_ext=c 1673+ac_cpp='$CPP $CPPFLAGS' 1674+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1675+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1676+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1677+ 1678+fi 1679+ 1680+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_float_round_use" >&5 1681+$as_echo "$glibcxx_cv_func_float_round_use" >&6; } 1682+ if test x$glibcxx_cv_func_float_round_use = x"yes"; then 1683+ for ac_func in ceilf floorf 1684+do : 1685+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 1686+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 1687+eval as_val=\$$as_ac_var 1688+ if test "x$as_val" = x""yes; then : 1689+ cat >>confdefs.h <<_ACEOF 1690+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 1691+_ACEOF 1692+ 1693+fi 1694+done 1695+ 1696+ else 1697+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _float round functions" >&5 1698+$as_echo_n "checking for _float round functions... " >&6; } 1699+ if test "${glibcxx_cv_func__float_round_use+set}" = set; then : 1700+ $as_echo_n "(cached) " >&6 1701+else 1702+ 1703+ 1704+ ac_ext=cpp 1705+ac_cpp='$CXXCPP $CPPFLAGS' 1706+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1707+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1708+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1709+ 1710+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1711+/* end confdefs.h. */ 1712+#include <math.h> 1713+int 1714+main () 1715+{ 1716+_ceilf (0); _floorf (0); 1717+ ; 1718+ return 0; 1719+} 1720+_ACEOF 1721+if ac_fn_cxx_try_compile "$LINENO"; then : 1722+ glibcxx_cv_func__float_round_use=yes 1723+else 1724+ glibcxx_cv_func__float_round_use=no 1725+fi 1726+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1727+ ac_ext=c 1728+ac_cpp='$CPP $CPPFLAGS' 1729+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1730+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1731+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1732+ 1733+fi 1734+ 1735+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__float_round_use" >&5 1736+$as_echo "$glibcxx_cv_func__float_round_use" >&6; } 1737+ if test x$glibcxx_cv_func__float_round_use = x"yes"; then 1738+ for ac_func in _ceilf _floorf 1739+do : 1740+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 1741+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 1742+eval as_val=\$$as_ac_var 1743+ if test "x$as_val" = x""yes; then : 1744+ cat >>confdefs.h <<_ACEOF 1745+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 1746+_ACEOF 1747+ 1748+fi 1749+done 1750+ 1751+ fi 1752+ fi 1753+ 1754+ 1755+ 1756+ 1757+ 1758+ 1759+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for expf declaration" >&5 1760+$as_echo_n "checking for expf declaration... " >&6; } 1761+ if test x${glibcxx_cv_func_expf_use+set} != xset; then 1762+ if test "${glibcxx_cv_func_expf_use+set}" = set; then : 1763+ $as_echo_n "(cached) " >&6 1764+else 1765+ 1766+ 1767+ ac_ext=cpp 1768+ac_cpp='$CXXCPP $CPPFLAGS' 1769+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1770+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1771+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1772+ 1773+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1774+/* end confdefs.h. */ 1775+#include <math.h> 1776+ #ifdef HAVE_IEEEFP_H 1777+ #include <ieeefp.h> 1778+ #endif 1779+ 1780+int 1781+main () 1782+{ 1783+ expf(0); 1784+ ; 1785+ return 0; 1786+} 1787+_ACEOF 1788+if ac_fn_cxx_try_compile "$LINENO"; then : 1789+ glibcxx_cv_func_expf_use=yes 1790+else 1791+ glibcxx_cv_func_expf_use=no 1792+fi 1793+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1794+ ac_ext=c 1795+ac_cpp='$CPP $CPPFLAGS' 1796+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1797+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1798+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1799+ 1800+ 1801+fi 1802+ 1803+ fi 1804+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_expf_use" >&5 1805+$as_echo "$glibcxx_cv_func_expf_use" >&6; } 1806+ 1807+ if test x$glibcxx_cv_func_expf_use = x"yes"; then 1808+ for ac_func in expf 1809+do : 1810+ ac_fn_c_check_func "$LINENO" "expf" "ac_cv_func_expf" 1811+if test "x$ac_cv_func_expf" = x""yes; then : 1812+ cat >>confdefs.h <<_ACEOF 1813+#define HAVE_EXPF 1 1814+_ACEOF 1815+ 1816+fi 1817+done 1818+ 1819+ else 1820+ 1821+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _expf declaration" >&5 1822+$as_echo_n "checking for _expf declaration... " >&6; } 1823+ if test x${glibcxx_cv_func__expf_use+set} != xset; then 1824+ if test "${glibcxx_cv_func__expf_use+set}" = set; then : 1825+ $as_echo_n "(cached) " >&6 1826+else 1827+ 1828+ 1829+ ac_ext=cpp 1830+ac_cpp='$CXXCPP $CPPFLAGS' 1831+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1832+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1833+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1834+ 1835+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1836+/* end confdefs.h. */ 1837+#include <math.h> 1838+ #ifdef HAVE_IEEEFP_H 1839+ #include <ieeefp.h> 1840+ #endif 1841+ 1842+int 1843+main () 1844+{ 1845+ _expf(0); 1846+ ; 1847+ return 0; 1848+} 1849+_ACEOF 1850+if ac_fn_cxx_try_compile "$LINENO"; then : 1851+ glibcxx_cv_func__expf_use=yes 1852+else 1853+ glibcxx_cv_func__expf_use=no 1854+fi 1855+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1856+ ac_ext=c 1857+ac_cpp='$CPP $CPPFLAGS' 1858+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1859+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1860+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1861+ 1862+ 1863+fi 1864+ 1865+ fi 1866+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__expf_use" >&5 1867+$as_echo "$glibcxx_cv_func__expf_use" >&6; } 1868+ 1869+ if test x$glibcxx_cv_func__expf_use = x"yes"; then 1870+ for ac_func in _expf 1871+do : 1872+ ac_fn_c_check_func "$LINENO" "_expf" "ac_cv_func__expf" 1873+if test "x$ac_cv_func__expf" = x""yes; then : 1874+ cat >>confdefs.h <<_ACEOF 1875+#define HAVE__EXPF 1 1876+_ACEOF 1877+ 1878+fi 1879+done 1880+ 1881+ fi 1882+ fi 1883+ 1884+ 1885+ 1886+ 1887+ 1888+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isnanf declaration" >&5 1889+$as_echo_n "checking for isnanf declaration... " >&6; } 1890+ if test x${glibcxx_cv_func_isnanf_use+set} != xset; then 1891+ if test "${glibcxx_cv_func_isnanf_use+set}" = set; then : 1892+ $as_echo_n "(cached) " >&6 1893+else 1894+ 1895+ 1896+ ac_ext=cpp 1897+ac_cpp='$CXXCPP $CPPFLAGS' 1898+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1899+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1900+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1901+ 1902+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1903+/* end confdefs.h. */ 1904+#include <math.h> 1905+ #ifdef HAVE_IEEEFP_H 1906+ #include <ieeefp.h> 1907+ #endif 1908+ 1909+int 1910+main () 1911+{ 1912+ isnanf(0); 1913+ ; 1914+ return 0; 1915+} 1916+_ACEOF 1917+if ac_fn_cxx_try_compile "$LINENO"; then : 1918+ glibcxx_cv_func_isnanf_use=yes 1919+else 1920+ glibcxx_cv_func_isnanf_use=no 1921+fi 1922+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1923+ ac_ext=c 1924+ac_cpp='$CPP $CPPFLAGS' 1925+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1926+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1927+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1928+ 1929+ 1930+fi 1931+ 1932+ fi 1933+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isnanf_use" >&5 1934+$as_echo "$glibcxx_cv_func_isnanf_use" >&6; } 1935+ 1936+ if test x$glibcxx_cv_func_isnanf_use = x"yes"; then 1937+ for ac_func in isnanf 1938+do : 1939+ ac_fn_c_check_func "$LINENO" "isnanf" "ac_cv_func_isnanf" 1940+if test "x$ac_cv_func_isnanf" = x""yes; then : 1941+ cat >>confdefs.h <<_ACEOF 1942+#define HAVE_ISNANF 1 1943+_ACEOF 1944+ 1945+fi 1946+done 1947+ 1948+ else 1949+ 1950+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isnanf declaration" >&5 1951+$as_echo_n "checking for _isnanf declaration... " >&6; } 1952+ if test x${glibcxx_cv_func__isnanf_use+set} != xset; then 1953+ if test "${glibcxx_cv_func__isnanf_use+set}" = set; then : 1954+ $as_echo_n "(cached) " >&6 1955+else 1956+ 1957+ 1958+ ac_ext=cpp 1959+ac_cpp='$CXXCPP $CPPFLAGS' 1960+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1961+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1962+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 1963+ 1964+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 1965+/* end confdefs.h. */ 1966+#include <math.h> 1967+ #ifdef HAVE_IEEEFP_H 1968+ #include <ieeefp.h> 1969+ #endif 1970+ 1971+int 1972+main () 1973+{ 1974+ _isnanf(0); 1975+ ; 1976+ return 0; 1977+} 1978+_ACEOF 1979+if ac_fn_cxx_try_compile "$LINENO"; then : 1980+ glibcxx_cv_func__isnanf_use=yes 1981+else 1982+ glibcxx_cv_func__isnanf_use=no 1983+fi 1984+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 1985+ ac_ext=c 1986+ac_cpp='$CPP $CPPFLAGS' 1987+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 1988+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 1989+ac_compiler_gnu=$ac_cv_c_compiler_gnu 1990+ 1991+ 1992+fi 1993+ 1994+ fi 1995+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isnanf_use" >&5 1996+$as_echo "$glibcxx_cv_func__isnanf_use" >&6; } 1997+ 1998+ if test x$glibcxx_cv_func__isnanf_use = x"yes"; then 1999+ for ac_func in _isnanf 2000+do : 2001+ ac_fn_c_check_func "$LINENO" "_isnanf" "ac_cv_func__isnanf" 2002+if test "x$ac_cv_func__isnanf" = x""yes; then : 2003+ cat >>confdefs.h <<_ACEOF 2004+#define HAVE__ISNANF 1 2005+_ACEOF 2006+ 2007+fi 2008+done 2009+ 2010+ fi 2011+ fi 2012+ 2013+ 2014+ 2015+ 2016+ 2017+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isinff declaration" >&5 2018+$as_echo_n "checking for isinff declaration... " >&6; } 2019+ if test x${glibcxx_cv_func_isinff_use+set} != xset; then 2020+ if test "${glibcxx_cv_func_isinff_use+set}" = set; then : 2021+ $as_echo_n "(cached) " >&6 2022+else 2023+ 2024+ 2025+ ac_ext=cpp 2026+ac_cpp='$CXXCPP $CPPFLAGS' 2027+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2028+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2029+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2030+ 2031+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2032+/* end confdefs.h. */ 2033+#include <math.h> 2034+ #ifdef HAVE_IEEEFP_H 2035+ #include <ieeefp.h> 2036+ #endif 2037+ 2038+int 2039+main () 2040+{ 2041+ isinff(0); 2042+ ; 2043+ return 0; 2044+} 2045+_ACEOF 2046+if ac_fn_cxx_try_compile "$LINENO"; then : 2047+ glibcxx_cv_func_isinff_use=yes 2048+else 2049+ glibcxx_cv_func_isinff_use=no 2050+fi 2051+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2052+ ac_ext=c 2053+ac_cpp='$CPP $CPPFLAGS' 2054+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2055+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2056+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2057+ 2058+ 2059+fi 2060+ 2061+ fi 2062+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isinff_use" >&5 2063+$as_echo "$glibcxx_cv_func_isinff_use" >&6; } 2064+ 2065+ if test x$glibcxx_cv_func_isinff_use = x"yes"; then 2066+ for ac_func in isinff 2067+do : 2068+ ac_fn_c_check_func "$LINENO" "isinff" "ac_cv_func_isinff" 2069+if test "x$ac_cv_func_isinff" = x""yes; then : 2070+ cat >>confdefs.h <<_ACEOF 2071+#define HAVE_ISINFF 1 2072+_ACEOF 2073+ 2074+fi 2075+done 2076+ 2077+ else 2078+ 2079+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isinff declaration" >&5 2080+$as_echo_n "checking for _isinff declaration... " >&6; } 2081+ if test x${glibcxx_cv_func__isinff_use+set} != xset; then 2082+ if test "${glibcxx_cv_func__isinff_use+set}" = set; then : 2083+ $as_echo_n "(cached) " >&6 2084+else 2085+ 2086+ 2087+ ac_ext=cpp 2088+ac_cpp='$CXXCPP $CPPFLAGS' 2089+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2090+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2091+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2092+ 2093+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2094+/* end confdefs.h. */ 2095+#include <math.h> 2096+ #ifdef HAVE_IEEEFP_H 2097+ #include <ieeefp.h> 2098+ #endif 2099+ 2100+int 2101+main () 2102+{ 2103+ _isinff(0); 2104+ ; 2105+ return 0; 2106+} 2107+_ACEOF 2108+if ac_fn_cxx_try_compile "$LINENO"; then : 2109+ glibcxx_cv_func__isinff_use=yes 2110+else 2111+ glibcxx_cv_func__isinff_use=no 2112+fi 2113+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2114+ ac_ext=c 2115+ac_cpp='$CPP $CPPFLAGS' 2116+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2117+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2118+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2119+ 2120+ 2121+fi 2122+ 2123+ fi 2124+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isinff_use" >&5 2125+$as_echo "$glibcxx_cv_func__isinff_use" >&6; } 2126+ 2127+ if test x$glibcxx_cv_func__isinff_use = x"yes"; then 2128+ for ac_func in _isinff 2129+do : 2130+ ac_fn_c_check_func "$LINENO" "_isinff" "ac_cv_func__isinff" 2131+if test "x$ac_cv_func__isinff" = x""yes; then : 2132+ cat >>confdefs.h <<_ACEOF 2133+#define HAVE__ISINFF 1 2134+_ACEOF 2135+ 2136+fi 2137+done 2138+ 2139+ fi 2140+ fi 2141+ 2142+ 2143+ 2144+ 2145+ 2146+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for atan2f declaration" >&5 2147+$as_echo_n "checking for atan2f declaration... " >&6; } 2148+ if test x${glibcxx_cv_func_atan2f_use+set} != xset; then 2149+ if test "${glibcxx_cv_func_atan2f_use+set}" = set; then : 2150+ $as_echo_n "(cached) " >&6 2151+else 2152+ 2153+ 2154+ ac_ext=cpp 2155+ac_cpp='$CXXCPP $CPPFLAGS' 2156+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2157+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2158+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2159+ 2160+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2161+/* end confdefs.h. */ 2162+#include <math.h> 2163+int 2164+main () 2165+{ 2166+ atan2f(0, 0); 2167+ ; 2168+ return 0; 2169+} 2170+_ACEOF 2171+if ac_fn_cxx_try_compile "$LINENO"; then : 2172+ glibcxx_cv_func_atan2f_use=yes 2173+else 2174+ glibcxx_cv_func_atan2f_use=no 2175+fi 2176+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2177+ ac_ext=c 2178+ac_cpp='$CPP $CPPFLAGS' 2179+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2180+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2181+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2182+ 2183+ 2184+fi 2185+ 2186+ fi 2187+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_atan2f_use" >&5 2188+$as_echo "$glibcxx_cv_func_atan2f_use" >&6; } 2189+ 2190+ if test x$glibcxx_cv_func_atan2f_use = x"yes"; then 2191+ for ac_func in atan2f 2192+do : 2193+ ac_fn_c_check_func "$LINENO" "atan2f" "ac_cv_func_atan2f" 2194+if test "x$ac_cv_func_atan2f" = x""yes; then : 2195+ cat >>confdefs.h <<_ACEOF 2196+#define HAVE_ATAN2F 1 2197+_ACEOF 2198+ 2199+fi 2200+done 2201+ 2202+ else 2203+ 2204+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _atan2f declaration" >&5 2205+$as_echo_n "checking for _atan2f declaration... " >&6; } 2206+ if test x${glibcxx_cv_func__atan2f_use+set} != xset; then 2207+ if test "${glibcxx_cv_func__atan2f_use+set}" = set; then : 2208+ $as_echo_n "(cached) " >&6 2209+else 2210+ 2211+ 2212+ ac_ext=cpp 2213+ac_cpp='$CXXCPP $CPPFLAGS' 2214+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2215+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2216+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2217+ 2218+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2219+/* end confdefs.h. */ 2220+#include <math.h> 2221+int 2222+main () 2223+{ 2224+ _atan2f(0, 0); 2225+ ; 2226+ return 0; 2227+} 2228+_ACEOF 2229+if ac_fn_cxx_try_compile "$LINENO"; then : 2230+ glibcxx_cv_func__atan2f_use=yes 2231+else 2232+ glibcxx_cv_func__atan2f_use=no 2233+fi 2234+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2235+ ac_ext=c 2236+ac_cpp='$CPP $CPPFLAGS' 2237+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2238+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2239+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2240+ 2241+ 2242+fi 2243+ 2244+ fi 2245+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__atan2f_use" >&5 2246+$as_echo "$glibcxx_cv_func__atan2f_use" >&6; } 2247+ 2248+ if test x$glibcxx_cv_func__atan2f_use = x"yes"; then 2249+ for ac_func in _atan2f 2250+do : 2251+ ac_fn_c_check_func "$LINENO" "_atan2f" "ac_cv_func__atan2f" 2252+if test "x$ac_cv_func__atan2f" = x""yes; then : 2253+ cat >>confdefs.h <<_ACEOF 2254+#define HAVE__ATAN2F 1 2255+_ACEOF 2256+ 2257+fi 2258+done 2259+ 2260+ fi 2261+ fi 2262+ 2263+ 2264+ 2265+ 2266+ 2267+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fabsf declaration" >&5 2268+$as_echo_n "checking for fabsf declaration... " >&6; } 2269+ if test x${glibcxx_cv_func_fabsf_use+set} != xset; then 2270+ if test "${glibcxx_cv_func_fabsf_use+set}" = set; then : 2271+ $as_echo_n "(cached) " >&6 2272+else 2273+ 2274+ 2275+ ac_ext=cpp 2276+ac_cpp='$CXXCPP $CPPFLAGS' 2277+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2278+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2279+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2280+ 2281+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2282+/* end confdefs.h. */ 2283+#include <math.h> 2284+ #ifdef HAVE_IEEEFP_H 2285+ #include <ieeefp.h> 2286+ #endif 2287+ 2288+int 2289+main () 2290+{ 2291+ fabsf(0); 2292+ ; 2293+ return 0; 2294+} 2295+_ACEOF 2296+if ac_fn_cxx_try_compile "$LINENO"; then : 2297+ glibcxx_cv_func_fabsf_use=yes 2298+else 2299+ glibcxx_cv_func_fabsf_use=no 2300+fi 2301+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2302+ ac_ext=c 2303+ac_cpp='$CPP $CPPFLAGS' 2304+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2305+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2306+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2307+ 2308+ 2309+fi 2310+ 2311+ fi 2312+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_fabsf_use" >&5 2313+$as_echo "$glibcxx_cv_func_fabsf_use" >&6; } 2314+ 2315+ if test x$glibcxx_cv_func_fabsf_use = x"yes"; then 2316+ for ac_func in fabsf 2317+do : 2318+ ac_fn_c_check_func "$LINENO" "fabsf" "ac_cv_func_fabsf" 2319+if test "x$ac_cv_func_fabsf" = x""yes; then : 2320+ cat >>confdefs.h <<_ACEOF 2321+#define HAVE_FABSF 1 2322+_ACEOF 2323+ 2324+fi 2325+done 2326+ 2327+ else 2328+ 2329+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _fabsf declaration" >&5 2330+$as_echo_n "checking for _fabsf declaration... " >&6; } 2331+ if test x${glibcxx_cv_func__fabsf_use+set} != xset; then 2332+ if test "${glibcxx_cv_func__fabsf_use+set}" = set; then : 2333+ $as_echo_n "(cached) " >&6 2334+else 2335+ 2336+ 2337+ ac_ext=cpp 2338+ac_cpp='$CXXCPP $CPPFLAGS' 2339+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2340+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2341+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2342+ 2343+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2344+/* end confdefs.h. */ 2345+#include <math.h> 2346+ #ifdef HAVE_IEEEFP_H 2347+ #include <ieeefp.h> 2348+ #endif 2349+ 2350+int 2351+main () 2352+{ 2353+ _fabsf(0); 2354+ ; 2355+ return 0; 2356+} 2357+_ACEOF 2358+if ac_fn_cxx_try_compile "$LINENO"; then : 2359+ glibcxx_cv_func__fabsf_use=yes 2360+else 2361+ glibcxx_cv_func__fabsf_use=no 2362+fi 2363+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2364+ ac_ext=c 2365+ac_cpp='$CPP $CPPFLAGS' 2366+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2367+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2368+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2369+ 2370+ 2371+fi 2372+ 2373+ fi 2374+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__fabsf_use" >&5 2375+$as_echo "$glibcxx_cv_func__fabsf_use" >&6; } 2376+ 2377+ if test x$glibcxx_cv_func__fabsf_use = x"yes"; then 2378+ for ac_func in _fabsf 2379+do : 2380+ ac_fn_c_check_func "$LINENO" "_fabsf" "ac_cv_func__fabsf" 2381+if test "x$ac_cv_func__fabsf" = x""yes; then : 2382+ cat >>confdefs.h <<_ACEOF 2383+#define HAVE__FABSF 1 2384+_ACEOF 2385+ 2386+fi 2387+done 2388+ 2389+ fi 2390+ fi 2391+ 2392+ 2393+ 2394+ 2395+ 2396+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fmodf declaration" >&5 2397+$as_echo_n "checking for fmodf declaration... " >&6; } 2398+ if test x${glibcxx_cv_func_fmodf_use+set} != xset; then 2399+ if test "${glibcxx_cv_func_fmodf_use+set}" = set; then : 2400+ $as_echo_n "(cached) " >&6 2401+else 2402+ 2403+ 2404+ ac_ext=cpp 2405+ac_cpp='$CXXCPP $CPPFLAGS' 2406+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2407+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2408+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2409+ 2410+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2411+/* end confdefs.h. */ 2412+#include <math.h> 2413+int 2414+main () 2415+{ 2416+ fmodf(0, 0); 2417+ ; 2418+ return 0; 2419+} 2420+_ACEOF 2421+if ac_fn_cxx_try_compile "$LINENO"; then : 2422+ glibcxx_cv_func_fmodf_use=yes 2423+else 2424+ glibcxx_cv_func_fmodf_use=no 2425+fi 2426+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2427+ ac_ext=c 2428+ac_cpp='$CPP $CPPFLAGS' 2429+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2430+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2431+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2432+ 2433+ 2434+fi 2435+ 2436+ fi 2437+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_fmodf_use" >&5 2438+$as_echo "$glibcxx_cv_func_fmodf_use" >&6; } 2439+ 2440+ if test x$glibcxx_cv_func_fmodf_use = x"yes"; then 2441+ for ac_func in fmodf 2442+do : 2443+ ac_fn_c_check_func "$LINENO" "fmodf" "ac_cv_func_fmodf" 2444+if test "x$ac_cv_func_fmodf" = x""yes; then : 2445+ cat >>confdefs.h <<_ACEOF 2446+#define HAVE_FMODF 1 2447+_ACEOF 2448+ 2449+fi 2450+done 2451+ 2452+ else 2453+ 2454+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _fmodf declaration" >&5 2455+$as_echo_n "checking for _fmodf declaration... " >&6; } 2456+ if test x${glibcxx_cv_func__fmodf_use+set} != xset; then 2457+ if test "${glibcxx_cv_func__fmodf_use+set}" = set; then : 2458+ $as_echo_n "(cached) " >&6 2459+else 2460+ 2461+ 2462+ ac_ext=cpp 2463+ac_cpp='$CXXCPP $CPPFLAGS' 2464+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2465+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2466+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2467+ 2468+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2469+/* end confdefs.h. */ 2470+#include <math.h> 2471+int 2472+main () 2473+{ 2474+ _fmodf(0, 0); 2475+ ; 2476+ return 0; 2477+} 2478+_ACEOF 2479+if ac_fn_cxx_try_compile "$LINENO"; then : 2480+ glibcxx_cv_func__fmodf_use=yes 2481+else 2482+ glibcxx_cv_func__fmodf_use=no 2483+fi 2484+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2485+ ac_ext=c 2486+ac_cpp='$CPP $CPPFLAGS' 2487+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2488+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2489+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2490+ 2491+ 2492+fi 2493+ 2494+ fi 2495+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__fmodf_use" >&5 2496+$as_echo "$glibcxx_cv_func__fmodf_use" >&6; } 2497+ 2498+ if test x$glibcxx_cv_func__fmodf_use = x"yes"; then 2499+ for ac_func in _fmodf 2500+do : 2501+ ac_fn_c_check_func "$LINENO" "_fmodf" "ac_cv_func__fmodf" 2502+if test "x$ac_cv_func__fmodf" = x""yes; then : 2503+ cat >>confdefs.h <<_ACEOF 2504+#define HAVE__FMODF 1 2505+_ACEOF 2506+ 2507+fi 2508+done 2509+ 2510+ fi 2511+ fi 2512+ 2513+ 2514+ 2515+ 2516+ 2517+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for frexpf declaration" >&5 2518+$as_echo_n "checking for frexpf declaration... " >&6; } 2519+ if test x${glibcxx_cv_func_frexpf_use+set} != xset; then 2520+ if test "${glibcxx_cv_func_frexpf_use+set}" = set; then : 2521+ $as_echo_n "(cached) " >&6 2522+else 2523+ 2524+ 2525+ ac_ext=cpp 2526+ac_cpp='$CXXCPP $CPPFLAGS' 2527+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2528+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2529+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2530+ 2531+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2532+/* end confdefs.h. */ 2533+#include <math.h> 2534+int 2535+main () 2536+{ 2537+ frexpf(0, 0); 2538+ ; 2539+ return 0; 2540+} 2541+_ACEOF 2542+if ac_fn_cxx_try_compile "$LINENO"; then : 2543+ glibcxx_cv_func_frexpf_use=yes 2544+else 2545+ glibcxx_cv_func_frexpf_use=no 2546+fi 2547+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2548+ ac_ext=c 2549+ac_cpp='$CPP $CPPFLAGS' 2550+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2551+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2552+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2553+ 2554+ 2555+fi 2556+ 2557+ fi 2558+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_frexpf_use" >&5 2559+$as_echo "$glibcxx_cv_func_frexpf_use" >&6; } 2560+ 2561+ if test x$glibcxx_cv_func_frexpf_use = x"yes"; then 2562+ for ac_func in frexpf 2563+do : 2564+ ac_fn_c_check_func "$LINENO" "frexpf" "ac_cv_func_frexpf" 2565+if test "x$ac_cv_func_frexpf" = x""yes; then : 2566+ cat >>confdefs.h <<_ACEOF 2567+#define HAVE_FREXPF 1 2568+_ACEOF 2569+ 2570+fi 2571+done 2572+ 2573+ else 2574+ 2575+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _frexpf declaration" >&5 2576+$as_echo_n "checking for _frexpf declaration... " >&6; } 2577+ if test x${glibcxx_cv_func__frexpf_use+set} != xset; then 2578+ if test "${glibcxx_cv_func__frexpf_use+set}" = set; then : 2579+ $as_echo_n "(cached) " >&6 2580+else 2581+ 2582+ 2583+ ac_ext=cpp 2584+ac_cpp='$CXXCPP $CPPFLAGS' 2585+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2586+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2587+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2588+ 2589+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2590+/* end confdefs.h. */ 2591+#include <math.h> 2592+int 2593+main () 2594+{ 2595+ _frexpf(0, 0); 2596+ ; 2597+ return 0; 2598+} 2599+_ACEOF 2600+if ac_fn_cxx_try_compile "$LINENO"; then : 2601+ glibcxx_cv_func__frexpf_use=yes 2602+else 2603+ glibcxx_cv_func__frexpf_use=no 2604+fi 2605+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2606+ ac_ext=c 2607+ac_cpp='$CPP $CPPFLAGS' 2608+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2609+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2610+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2611+ 2612+ 2613+fi 2614+ 2615+ fi 2616+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__frexpf_use" >&5 2617+$as_echo "$glibcxx_cv_func__frexpf_use" >&6; } 2618+ 2619+ if test x$glibcxx_cv_func__frexpf_use = x"yes"; then 2620+ for ac_func in _frexpf 2621+do : 2622+ ac_fn_c_check_func "$LINENO" "_frexpf" "ac_cv_func__frexpf" 2623+if test "x$ac_cv_func__frexpf" = x""yes; then : 2624+ cat >>confdefs.h <<_ACEOF 2625+#define HAVE__FREXPF 1 2626+_ACEOF 2627+ 2628+fi 2629+done 2630+ 2631+ fi 2632+ fi 2633+ 2634+ 2635+ 2636+ 2637+ 2638+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hypotf declaration" >&5 2639+$as_echo_n "checking for hypotf declaration... " >&6; } 2640+ if test x${glibcxx_cv_func_hypotf_use+set} != xset; then 2641+ if test "${glibcxx_cv_func_hypotf_use+set}" = set; then : 2642+ $as_echo_n "(cached) " >&6 2643+else 2644+ 2645+ 2646+ ac_ext=cpp 2647+ac_cpp='$CXXCPP $CPPFLAGS' 2648+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2649+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2650+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2651+ 2652+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2653+/* end confdefs.h. */ 2654+#include <math.h> 2655+int 2656+main () 2657+{ 2658+ hypotf(0, 0); 2659+ ; 2660+ return 0; 2661+} 2662+_ACEOF 2663+if ac_fn_cxx_try_compile "$LINENO"; then : 2664+ glibcxx_cv_func_hypotf_use=yes 2665+else 2666+ glibcxx_cv_func_hypotf_use=no 2667+fi 2668+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2669+ ac_ext=c 2670+ac_cpp='$CPP $CPPFLAGS' 2671+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2672+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2673+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2674+ 2675+ 2676+fi 2677+ 2678+ fi 2679+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_hypotf_use" >&5 2680+$as_echo "$glibcxx_cv_func_hypotf_use" >&6; } 2681+ 2682+ if test x$glibcxx_cv_func_hypotf_use = x"yes"; then 2683+ for ac_func in hypotf 2684+do : 2685+ ac_fn_c_check_func "$LINENO" "hypotf" "ac_cv_func_hypotf" 2686+if test "x$ac_cv_func_hypotf" = x""yes; then : 2687+ cat >>confdefs.h <<_ACEOF 2688+#define HAVE_HYPOTF 1 2689+_ACEOF 2690+ 2691+fi 2692+done 2693+ 2694+ else 2695+ 2696+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _hypotf declaration" >&5 2697+$as_echo_n "checking for _hypotf declaration... " >&6; } 2698+ if test x${glibcxx_cv_func__hypotf_use+set} != xset; then 2699+ if test "${glibcxx_cv_func__hypotf_use+set}" = set; then : 2700+ $as_echo_n "(cached) " >&6 2701+else 2702+ 2703+ 2704+ ac_ext=cpp 2705+ac_cpp='$CXXCPP $CPPFLAGS' 2706+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2707+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2708+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2709+ 2710+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2711+/* end confdefs.h. */ 2712+#include <math.h> 2713+int 2714+main () 2715+{ 2716+ _hypotf(0, 0); 2717+ ; 2718+ return 0; 2719+} 2720+_ACEOF 2721+if ac_fn_cxx_try_compile "$LINENO"; then : 2722+ glibcxx_cv_func__hypotf_use=yes 2723+else 2724+ glibcxx_cv_func__hypotf_use=no 2725+fi 2726+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2727+ ac_ext=c 2728+ac_cpp='$CPP $CPPFLAGS' 2729+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2730+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2731+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2732+ 2733+ 2734+fi 2735+ 2736+ fi 2737+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__hypotf_use" >&5 2738+$as_echo "$glibcxx_cv_func__hypotf_use" >&6; } 2739+ 2740+ if test x$glibcxx_cv_func__hypotf_use = x"yes"; then 2741+ for ac_func in _hypotf 2742+do : 2743+ ac_fn_c_check_func "$LINENO" "_hypotf" "ac_cv_func__hypotf" 2744+if test "x$ac_cv_func__hypotf" = x""yes; then : 2745+ cat >>confdefs.h <<_ACEOF 2746+#define HAVE__HYPOTF 1 2747+_ACEOF 2748+ 2749+fi 2750+done 2751+ 2752+ fi 2753+ fi 2754+ 2755+ 2756+ 2757+ 2758+ 2759+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldexpf declaration" >&5 2760+$as_echo_n "checking for ldexpf declaration... " >&6; } 2761+ if test x${glibcxx_cv_func_ldexpf_use+set} != xset; then 2762+ if test "${glibcxx_cv_func_ldexpf_use+set}" = set; then : 2763+ $as_echo_n "(cached) " >&6 2764+else 2765+ 2766+ 2767+ ac_ext=cpp 2768+ac_cpp='$CXXCPP $CPPFLAGS' 2769+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2770+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2771+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2772+ 2773+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2774+/* end confdefs.h. */ 2775+#include <math.h> 2776+int 2777+main () 2778+{ 2779+ ldexpf(0, 0); 2780+ ; 2781+ return 0; 2782+} 2783+_ACEOF 2784+if ac_fn_cxx_try_compile "$LINENO"; then : 2785+ glibcxx_cv_func_ldexpf_use=yes 2786+else 2787+ glibcxx_cv_func_ldexpf_use=no 2788+fi 2789+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2790+ ac_ext=c 2791+ac_cpp='$CPP $CPPFLAGS' 2792+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2793+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2794+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2795+ 2796+ 2797+fi 2798+ 2799+ fi 2800+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_ldexpf_use" >&5 2801+$as_echo "$glibcxx_cv_func_ldexpf_use" >&6; } 2802+ 2803+ if test x$glibcxx_cv_func_ldexpf_use = x"yes"; then 2804+ for ac_func in ldexpf 2805+do : 2806+ ac_fn_c_check_func "$LINENO" "ldexpf" "ac_cv_func_ldexpf" 2807+if test "x$ac_cv_func_ldexpf" = x""yes; then : 2808+ cat >>confdefs.h <<_ACEOF 2809+#define HAVE_LDEXPF 1 2810+_ACEOF 2811+ 2812+fi 2813+done 2814+ 2815+ else 2816+ 2817+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _ldexpf declaration" >&5 2818+$as_echo_n "checking for _ldexpf declaration... " >&6; } 2819+ if test x${glibcxx_cv_func__ldexpf_use+set} != xset; then 2820+ if test "${glibcxx_cv_func__ldexpf_use+set}" = set; then : 2821+ $as_echo_n "(cached) " >&6 2822+else 2823+ 2824+ 2825+ ac_ext=cpp 2826+ac_cpp='$CXXCPP $CPPFLAGS' 2827+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2828+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2829+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2830+ 2831+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2832+/* end confdefs.h. */ 2833+#include <math.h> 2834+int 2835+main () 2836+{ 2837+ _ldexpf(0, 0); 2838+ ; 2839+ return 0; 2840+} 2841+_ACEOF 2842+if ac_fn_cxx_try_compile "$LINENO"; then : 2843+ glibcxx_cv_func__ldexpf_use=yes 2844+else 2845+ glibcxx_cv_func__ldexpf_use=no 2846+fi 2847+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2848+ ac_ext=c 2849+ac_cpp='$CPP $CPPFLAGS' 2850+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2851+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2852+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2853+ 2854+ 2855+fi 2856+ 2857+ fi 2858+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__ldexpf_use" >&5 2859+$as_echo "$glibcxx_cv_func__ldexpf_use" >&6; } 2860+ 2861+ if test x$glibcxx_cv_func__ldexpf_use = x"yes"; then 2862+ for ac_func in _ldexpf 2863+do : 2864+ ac_fn_c_check_func "$LINENO" "_ldexpf" "ac_cv_func__ldexpf" 2865+if test "x$ac_cv_func__ldexpf" = x""yes; then : 2866+ cat >>confdefs.h <<_ACEOF 2867+#define HAVE__LDEXPF 1 2868+_ACEOF 2869+ 2870+fi 2871+done 2872+ 2873+ fi 2874+ fi 2875+ 2876+ 2877+ 2878+ 2879+ 2880+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for logf declaration" >&5 2881+$as_echo_n "checking for logf declaration... " >&6; } 2882+ if test x${glibcxx_cv_func_logf_use+set} != xset; then 2883+ if test "${glibcxx_cv_func_logf_use+set}" = set; then : 2884+ $as_echo_n "(cached) " >&6 2885+else 2886+ 2887+ 2888+ ac_ext=cpp 2889+ac_cpp='$CXXCPP $CPPFLAGS' 2890+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2891+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2892+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2893+ 2894+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2895+/* end confdefs.h. */ 2896+#include <math.h> 2897+ #ifdef HAVE_IEEEFP_H 2898+ #include <ieeefp.h> 2899+ #endif 2900+ 2901+int 2902+main () 2903+{ 2904+ logf(0); 2905+ ; 2906+ return 0; 2907+} 2908+_ACEOF 2909+if ac_fn_cxx_try_compile "$LINENO"; then : 2910+ glibcxx_cv_func_logf_use=yes 2911+else 2912+ glibcxx_cv_func_logf_use=no 2913+fi 2914+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2915+ ac_ext=c 2916+ac_cpp='$CPP $CPPFLAGS' 2917+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2918+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2919+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2920+ 2921+ 2922+fi 2923+ 2924+ fi 2925+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_logf_use" >&5 2926+$as_echo "$glibcxx_cv_func_logf_use" >&6; } 2927+ 2928+ if test x$glibcxx_cv_func_logf_use = x"yes"; then 2929+ for ac_func in logf 2930+do : 2931+ ac_fn_c_check_func "$LINENO" "logf" "ac_cv_func_logf" 2932+if test "x$ac_cv_func_logf" = x""yes; then : 2933+ cat >>confdefs.h <<_ACEOF 2934+#define HAVE_LOGF 1 2935+_ACEOF 2936+ 2937+fi 2938+done 2939+ 2940+ else 2941+ 2942+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _logf declaration" >&5 2943+$as_echo_n "checking for _logf declaration... " >&6; } 2944+ if test x${glibcxx_cv_func__logf_use+set} != xset; then 2945+ if test "${glibcxx_cv_func__logf_use+set}" = set; then : 2946+ $as_echo_n "(cached) " >&6 2947+else 2948+ 2949+ 2950+ ac_ext=cpp 2951+ac_cpp='$CXXCPP $CPPFLAGS' 2952+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2953+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2954+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 2955+ 2956+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 2957+/* end confdefs.h. */ 2958+#include <math.h> 2959+ #ifdef HAVE_IEEEFP_H 2960+ #include <ieeefp.h> 2961+ #endif 2962+ 2963+int 2964+main () 2965+{ 2966+ _logf(0); 2967+ ; 2968+ return 0; 2969+} 2970+_ACEOF 2971+if ac_fn_cxx_try_compile "$LINENO"; then : 2972+ glibcxx_cv_func__logf_use=yes 2973+else 2974+ glibcxx_cv_func__logf_use=no 2975+fi 2976+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 2977+ ac_ext=c 2978+ac_cpp='$CPP $CPPFLAGS' 2979+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 2980+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 2981+ac_compiler_gnu=$ac_cv_c_compiler_gnu 2982+ 2983+ 2984+fi 2985+ 2986+ fi 2987+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__logf_use" >&5 2988+$as_echo "$glibcxx_cv_func__logf_use" >&6; } 2989+ 2990+ if test x$glibcxx_cv_func__logf_use = x"yes"; then 2991+ for ac_func in _logf 2992+do : 2993+ ac_fn_c_check_func "$LINENO" "_logf" "ac_cv_func__logf" 2994+if test "x$ac_cv_func__logf" = x""yes; then : 2995+ cat >>confdefs.h <<_ACEOF 2996+#define HAVE__LOGF 1 2997+_ACEOF 2998+ 2999+fi 3000+done 3001+ 3002+ fi 3003+ fi 3004+ 3005+ 3006+ 3007+ 3008+ 3009+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for log10f declaration" >&5 3010+$as_echo_n "checking for log10f declaration... " >&6; } 3011+ if test x${glibcxx_cv_func_log10f_use+set} != xset; then 3012+ if test "${glibcxx_cv_func_log10f_use+set}" = set; then : 3013+ $as_echo_n "(cached) " >&6 3014+else 3015+ 3016+ 3017+ ac_ext=cpp 3018+ac_cpp='$CXXCPP $CPPFLAGS' 3019+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3020+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3021+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3022+ 3023+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3024+/* end confdefs.h. */ 3025+#include <math.h> 3026+ #ifdef HAVE_IEEEFP_H 3027+ #include <ieeefp.h> 3028+ #endif 3029+ 3030+int 3031+main () 3032+{ 3033+ log10f(0); 3034+ ; 3035+ return 0; 3036+} 3037+_ACEOF 3038+if ac_fn_cxx_try_compile "$LINENO"; then : 3039+ glibcxx_cv_func_log10f_use=yes 3040+else 3041+ glibcxx_cv_func_log10f_use=no 3042+fi 3043+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3044+ ac_ext=c 3045+ac_cpp='$CPP $CPPFLAGS' 3046+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3047+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3048+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3049+ 3050+ 3051+fi 3052+ 3053+ fi 3054+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_log10f_use" >&5 3055+$as_echo "$glibcxx_cv_func_log10f_use" >&6; } 3056+ 3057+ if test x$glibcxx_cv_func_log10f_use = x"yes"; then 3058+ for ac_func in log10f 3059+do : 3060+ ac_fn_c_check_func "$LINENO" "log10f" "ac_cv_func_log10f" 3061+if test "x$ac_cv_func_log10f" = x""yes; then : 3062+ cat >>confdefs.h <<_ACEOF 3063+#define HAVE_LOG10F 1 3064+_ACEOF 3065+ 3066+fi 3067+done 3068+ 3069+ else 3070+ 3071+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _log10f declaration" >&5 3072+$as_echo_n "checking for _log10f declaration... " >&6; } 3073+ if test x${glibcxx_cv_func__log10f_use+set} != xset; then 3074+ if test "${glibcxx_cv_func__log10f_use+set}" = set; then : 3075+ $as_echo_n "(cached) " >&6 3076+else 3077+ 3078+ 3079+ ac_ext=cpp 3080+ac_cpp='$CXXCPP $CPPFLAGS' 3081+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3082+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3083+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3084+ 3085+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3086+/* end confdefs.h. */ 3087+#include <math.h> 3088+ #ifdef HAVE_IEEEFP_H 3089+ #include <ieeefp.h> 3090+ #endif 3091+ 3092+int 3093+main () 3094+{ 3095+ _log10f(0); 3096+ ; 3097+ return 0; 3098+} 3099+_ACEOF 3100+if ac_fn_cxx_try_compile "$LINENO"; then : 3101+ glibcxx_cv_func__log10f_use=yes 3102+else 3103+ glibcxx_cv_func__log10f_use=no 3104+fi 3105+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3106+ ac_ext=c 3107+ac_cpp='$CPP $CPPFLAGS' 3108+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3109+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3110+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3111+ 3112+ 3113+fi 3114+ 3115+ fi 3116+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__log10f_use" >&5 3117+$as_echo "$glibcxx_cv_func__log10f_use" >&6; } 3118+ 3119+ if test x$glibcxx_cv_func__log10f_use = x"yes"; then 3120+ for ac_func in _log10f 3121+do : 3122+ ac_fn_c_check_func "$LINENO" "_log10f" "ac_cv_func__log10f" 3123+if test "x$ac_cv_func__log10f" = x""yes; then : 3124+ cat >>confdefs.h <<_ACEOF 3125+#define HAVE__LOG10F 1 3126+_ACEOF 3127+ 3128+fi 3129+done 3130+ 3131+ fi 3132+ fi 3133+ 3134+ 3135+ 3136+ 3137+ 3138+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for modff declaration" >&5 3139+$as_echo_n "checking for modff declaration... " >&6; } 3140+ if test x${glibcxx_cv_func_modff_use+set} != xset; then 3141+ if test "${glibcxx_cv_func_modff_use+set}" = set; then : 3142+ $as_echo_n "(cached) " >&6 3143+else 3144+ 3145+ 3146+ ac_ext=cpp 3147+ac_cpp='$CXXCPP $CPPFLAGS' 3148+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3149+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3150+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3151+ 3152+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3153+/* end confdefs.h. */ 3154+#include <math.h> 3155+int 3156+main () 3157+{ 3158+ modff(0, 0); 3159+ ; 3160+ return 0; 3161+} 3162+_ACEOF 3163+if ac_fn_cxx_try_compile "$LINENO"; then : 3164+ glibcxx_cv_func_modff_use=yes 3165+else 3166+ glibcxx_cv_func_modff_use=no 3167+fi 3168+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3169+ ac_ext=c 3170+ac_cpp='$CPP $CPPFLAGS' 3171+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3172+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3173+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3174+ 3175+ 3176+fi 3177+ 3178+ fi 3179+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_modff_use" >&5 3180+$as_echo "$glibcxx_cv_func_modff_use" >&6; } 3181+ 3182+ if test x$glibcxx_cv_func_modff_use = x"yes"; then 3183+ for ac_func in modff 3184+do : 3185+ ac_fn_c_check_func "$LINENO" "modff" "ac_cv_func_modff" 3186+if test "x$ac_cv_func_modff" = x""yes; then : 3187+ cat >>confdefs.h <<_ACEOF 3188+#define HAVE_MODFF 1 3189+_ACEOF 3190+ 3191+fi 3192+done 3193+ 3194+ else 3195+ 3196+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _modff declaration" >&5 3197+$as_echo_n "checking for _modff declaration... " >&6; } 3198+ if test x${glibcxx_cv_func__modff_use+set} != xset; then 3199+ if test "${glibcxx_cv_func__modff_use+set}" = set; then : 3200+ $as_echo_n "(cached) " >&6 3201+else 3202+ 3203+ 3204+ ac_ext=cpp 3205+ac_cpp='$CXXCPP $CPPFLAGS' 3206+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3207+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3208+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3209+ 3210+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3211+/* end confdefs.h. */ 3212+#include <math.h> 3213+int 3214+main () 3215+{ 3216+ _modff(0, 0); 3217+ ; 3218+ return 0; 3219+} 3220+_ACEOF 3221+if ac_fn_cxx_try_compile "$LINENO"; then : 3222+ glibcxx_cv_func__modff_use=yes 3223+else 3224+ glibcxx_cv_func__modff_use=no 3225+fi 3226+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3227+ ac_ext=c 3228+ac_cpp='$CPP $CPPFLAGS' 3229+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3230+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3231+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3232+ 3233+ 3234+fi 3235+ 3236+ fi 3237+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__modff_use" >&5 3238+$as_echo "$glibcxx_cv_func__modff_use" >&6; } 3239+ 3240+ if test x$glibcxx_cv_func__modff_use = x"yes"; then 3241+ for ac_func in _modff 3242+do : 3243+ ac_fn_c_check_func "$LINENO" "_modff" "ac_cv_func__modff" 3244+if test "x$ac_cv_func__modff" = x""yes; then : 3245+ cat >>confdefs.h <<_ACEOF 3246+#define HAVE__MODFF 1 3247+_ACEOF 3248+ 3249+fi 3250+done 3251+ 3252+ fi 3253+ fi 3254+ 3255+ 3256+ 3257+ 3258+ 3259+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for modf declaration" >&5 3260+$as_echo_n "checking for modf declaration... " >&6; } 3261+ if test x${glibcxx_cv_func_modf_use+set} != xset; then 3262+ if test "${glibcxx_cv_func_modf_use+set}" = set; then : 3263+ $as_echo_n "(cached) " >&6 3264+else 3265+ 3266+ 3267+ ac_ext=cpp 3268+ac_cpp='$CXXCPP $CPPFLAGS' 3269+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3270+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3271+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3272+ 3273+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3274+/* end confdefs.h. */ 3275+#include <math.h> 3276+int 3277+main () 3278+{ 3279+ modf(0, 0); 3280+ ; 3281+ return 0; 3282+} 3283+_ACEOF 3284+if ac_fn_cxx_try_compile "$LINENO"; then : 3285+ glibcxx_cv_func_modf_use=yes 3286+else 3287+ glibcxx_cv_func_modf_use=no 3288+fi 3289+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3290+ ac_ext=c 3291+ac_cpp='$CPP $CPPFLAGS' 3292+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3293+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3294+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3295+ 3296+ 3297+fi 3298+ 3299+ fi 3300+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_modf_use" >&5 3301+$as_echo "$glibcxx_cv_func_modf_use" >&6; } 3302+ 3303+ if test x$glibcxx_cv_func_modf_use = x"yes"; then 3304+ for ac_func in modf 3305+do : 3306+ ac_fn_c_check_func "$LINENO" "modf" "ac_cv_func_modf" 3307+if test "x$ac_cv_func_modf" = x""yes; then : 3308+ cat >>confdefs.h <<_ACEOF 3309+#define HAVE_MODF 1 3310+_ACEOF 3311+ 3312+fi 3313+done 3314+ 3315+ else 3316+ 3317+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _modf declaration" >&5 3318+$as_echo_n "checking for _modf declaration... " >&6; } 3319+ if test x${glibcxx_cv_func__modf_use+set} != xset; then 3320+ if test "${glibcxx_cv_func__modf_use+set}" = set; then : 3321+ $as_echo_n "(cached) " >&6 3322+else 3323+ 3324+ 3325+ ac_ext=cpp 3326+ac_cpp='$CXXCPP $CPPFLAGS' 3327+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3328+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3329+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3330+ 3331+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3332+/* end confdefs.h. */ 3333+#include <math.h> 3334+int 3335+main () 3336+{ 3337+ _modf(0, 0); 3338+ ; 3339+ return 0; 3340+} 3341+_ACEOF 3342+if ac_fn_cxx_try_compile "$LINENO"; then : 3343+ glibcxx_cv_func__modf_use=yes 3344+else 3345+ glibcxx_cv_func__modf_use=no 3346+fi 3347+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3348+ ac_ext=c 3349+ac_cpp='$CPP $CPPFLAGS' 3350+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3351+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3352+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3353+ 3354+ 3355+fi 3356+ 3357+ fi 3358+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__modf_use" >&5 3359+$as_echo "$glibcxx_cv_func__modf_use" >&6; } 3360+ 3361+ if test x$glibcxx_cv_func__modf_use = x"yes"; then 3362+ for ac_func in _modf 3363+do : 3364+ ac_fn_c_check_func "$LINENO" "_modf" "ac_cv_func__modf" 3365+if test "x$ac_cv_func__modf" = x""yes; then : 3366+ cat >>confdefs.h <<_ACEOF 3367+#define HAVE__MODF 1 3368+_ACEOF 3369+ 3370+fi 3371+done 3372+ 3373+ fi 3374+ fi 3375+ 3376+ 3377+ 3378+ 3379+ 3380+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for powf declaration" >&5 3381+$as_echo_n "checking for powf declaration... " >&6; } 3382+ if test x${glibcxx_cv_func_powf_use+set} != xset; then 3383+ if test "${glibcxx_cv_func_powf_use+set}" = set; then : 3384+ $as_echo_n "(cached) " >&6 3385+else 3386+ 3387+ 3388+ ac_ext=cpp 3389+ac_cpp='$CXXCPP $CPPFLAGS' 3390+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3391+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3392+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3393+ 3394+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3395+/* end confdefs.h. */ 3396+#include <math.h> 3397+int 3398+main () 3399+{ 3400+ powf(0, 0); 3401+ ; 3402+ return 0; 3403+} 3404+_ACEOF 3405+if ac_fn_cxx_try_compile "$LINENO"; then : 3406+ glibcxx_cv_func_powf_use=yes 3407+else 3408+ glibcxx_cv_func_powf_use=no 3409+fi 3410+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3411+ ac_ext=c 3412+ac_cpp='$CPP $CPPFLAGS' 3413+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3414+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3415+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3416+ 3417+ 3418+fi 3419+ 3420+ fi 3421+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_powf_use" >&5 3422+$as_echo "$glibcxx_cv_func_powf_use" >&6; } 3423+ 3424+ if test x$glibcxx_cv_func_powf_use = x"yes"; then 3425+ for ac_func in powf 3426+do : 3427+ ac_fn_c_check_func "$LINENO" "powf" "ac_cv_func_powf" 3428+if test "x$ac_cv_func_powf" = x""yes; then : 3429+ cat >>confdefs.h <<_ACEOF 3430+#define HAVE_POWF 1 3431+_ACEOF 3432+ 3433+fi 3434+done 3435+ 3436+ else 3437+ 3438+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _powf declaration" >&5 3439+$as_echo_n "checking for _powf declaration... " >&6; } 3440+ if test x${glibcxx_cv_func__powf_use+set} != xset; then 3441+ if test "${glibcxx_cv_func__powf_use+set}" = set; then : 3442+ $as_echo_n "(cached) " >&6 3443+else 3444+ 3445+ 3446+ ac_ext=cpp 3447+ac_cpp='$CXXCPP $CPPFLAGS' 3448+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3449+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3450+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3451+ 3452+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3453+/* end confdefs.h. */ 3454+#include <math.h> 3455+int 3456+main () 3457+{ 3458+ _powf(0, 0); 3459+ ; 3460+ return 0; 3461+} 3462+_ACEOF 3463+if ac_fn_cxx_try_compile "$LINENO"; then : 3464+ glibcxx_cv_func__powf_use=yes 3465+else 3466+ glibcxx_cv_func__powf_use=no 3467+fi 3468+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3469+ ac_ext=c 3470+ac_cpp='$CPP $CPPFLAGS' 3471+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3472+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3473+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3474+ 3475+ 3476+fi 3477+ 3478+ fi 3479+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__powf_use" >&5 3480+$as_echo "$glibcxx_cv_func__powf_use" >&6; } 3481+ 3482+ if test x$glibcxx_cv_func__powf_use = x"yes"; then 3483+ for ac_func in _powf 3484+do : 3485+ ac_fn_c_check_func "$LINENO" "_powf" "ac_cv_func__powf" 3486+if test "x$ac_cv_func__powf" = x""yes; then : 3487+ cat >>confdefs.h <<_ACEOF 3488+#define HAVE__POWF 1 3489+_ACEOF 3490+ 3491+fi 3492+done 3493+ 3494+ fi 3495+ fi 3496+ 3497+ 3498+ 3499+ 3500+ 3501+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sqrtf declaration" >&5 3502+$as_echo_n "checking for sqrtf declaration... " >&6; } 3503+ if test x${glibcxx_cv_func_sqrtf_use+set} != xset; then 3504+ if test "${glibcxx_cv_func_sqrtf_use+set}" = set; then : 3505+ $as_echo_n "(cached) " >&6 3506+else 3507+ 3508+ 3509+ ac_ext=cpp 3510+ac_cpp='$CXXCPP $CPPFLAGS' 3511+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3512+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3513+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3514+ 3515+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3516+/* end confdefs.h. */ 3517+#include <math.h> 3518+ #ifdef HAVE_IEEEFP_H 3519+ #include <ieeefp.h> 3520+ #endif 3521+ 3522+int 3523+main () 3524+{ 3525+ sqrtf(0); 3526+ ; 3527+ return 0; 3528+} 3529+_ACEOF 3530+if ac_fn_cxx_try_compile "$LINENO"; then : 3531+ glibcxx_cv_func_sqrtf_use=yes 3532+else 3533+ glibcxx_cv_func_sqrtf_use=no 3534+fi 3535+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3536+ ac_ext=c 3537+ac_cpp='$CPP $CPPFLAGS' 3538+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3539+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3540+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3541+ 3542+ 3543+fi 3544+ 3545+ fi 3546+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_sqrtf_use" >&5 3547+$as_echo "$glibcxx_cv_func_sqrtf_use" >&6; } 3548+ 3549+ if test x$glibcxx_cv_func_sqrtf_use = x"yes"; then 3550+ for ac_func in sqrtf 3551+do : 3552+ ac_fn_c_check_func "$LINENO" "sqrtf" "ac_cv_func_sqrtf" 3553+if test "x$ac_cv_func_sqrtf" = x""yes; then : 3554+ cat >>confdefs.h <<_ACEOF 3555+#define HAVE_SQRTF 1 3556+_ACEOF 3557+ 3558+fi 3559+done 3560+ 3561+ else 3562+ 3563+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _sqrtf declaration" >&5 3564+$as_echo_n "checking for _sqrtf declaration... " >&6; } 3565+ if test x${glibcxx_cv_func__sqrtf_use+set} != xset; then 3566+ if test "${glibcxx_cv_func__sqrtf_use+set}" = set; then : 3567+ $as_echo_n "(cached) " >&6 3568+else 3569+ 3570+ 3571+ ac_ext=cpp 3572+ac_cpp='$CXXCPP $CPPFLAGS' 3573+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3574+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3575+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3576+ 3577+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3578+/* end confdefs.h. */ 3579+#include <math.h> 3580+ #ifdef HAVE_IEEEFP_H 3581+ #include <ieeefp.h> 3582+ #endif 3583+ 3584+int 3585+main () 3586+{ 3587+ _sqrtf(0); 3588+ ; 3589+ return 0; 3590+} 3591+_ACEOF 3592+if ac_fn_cxx_try_compile "$LINENO"; then : 3593+ glibcxx_cv_func__sqrtf_use=yes 3594+else 3595+ glibcxx_cv_func__sqrtf_use=no 3596+fi 3597+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3598+ ac_ext=c 3599+ac_cpp='$CPP $CPPFLAGS' 3600+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3601+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3602+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3603+ 3604+ 3605+fi 3606+ 3607+ fi 3608+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__sqrtf_use" >&5 3609+$as_echo "$glibcxx_cv_func__sqrtf_use" >&6; } 3610+ 3611+ if test x$glibcxx_cv_func__sqrtf_use = x"yes"; then 3612+ for ac_func in _sqrtf 3613+do : 3614+ ac_fn_c_check_func "$LINENO" "_sqrtf" "ac_cv_func__sqrtf" 3615+if test "x$ac_cv_func__sqrtf" = x""yes; then : 3616+ cat >>confdefs.h <<_ACEOF 3617+#define HAVE__SQRTF 1 3618+_ACEOF 3619+ 3620+fi 3621+done 3622+ 3623+ fi 3624+ fi 3625+ 3626+ 3627+ 3628+ 3629+ 3630+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sincosf declaration" >&5 3631+$as_echo_n "checking for sincosf declaration... " >&6; } 3632+ if test x${glibcxx_cv_func_sincosf_use+set} != xset; then 3633+ if test "${glibcxx_cv_func_sincosf_use+set}" = set; then : 3634+ $as_echo_n "(cached) " >&6 3635+else 3636+ 3637+ 3638+ ac_ext=cpp 3639+ac_cpp='$CXXCPP $CPPFLAGS' 3640+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3641+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3642+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3643+ 3644+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3645+/* end confdefs.h. */ 3646+#include <math.h> 3647+int 3648+main () 3649+{ 3650+ sincosf(0, 0, 0); 3651+ ; 3652+ return 0; 3653+} 3654+_ACEOF 3655+if ac_fn_cxx_try_compile "$LINENO"; then : 3656+ glibcxx_cv_func_sincosf_use=yes 3657+else 3658+ glibcxx_cv_func_sincosf_use=no 3659+fi 3660+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3661+ ac_ext=c 3662+ac_cpp='$CPP $CPPFLAGS' 3663+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3664+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3665+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3666+ 3667+ 3668+fi 3669+ 3670+ fi 3671+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_sincosf_use" >&5 3672+$as_echo "$glibcxx_cv_func_sincosf_use" >&6; } 3673+ 3674+ if test x$glibcxx_cv_func_sincosf_use = x"yes"; then 3675+ for ac_func in sincosf 3676+do : 3677+ ac_fn_c_check_func "$LINENO" "sincosf" "ac_cv_func_sincosf" 3678+if test "x$ac_cv_func_sincosf" = x""yes; then : 3679+ cat >>confdefs.h <<_ACEOF 3680+#define HAVE_SINCOSF 1 3681+_ACEOF 3682+ 3683+fi 3684+done 3685+ 3686+ else 3687+ 3688+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _sincosf declaration" >&5 3689+$as_echo_n "checking for _sincosf declaration... " >&6; } 3690+ if test x${glibcxx_cv_func__sincosf_use+set} != xset; then 3691+ if test "${glibcxx_cv_func__sincosf_use+set}" = set; then : 3692+ $as_echo_n "(cached) " >&6 3693+else 3694+ 3695+ 3696+ ac_ext=cpp 3697+ac_cpp='$CXXCPP $CPPFLAGS' 3698+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3699+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3700+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3701+ 3702+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3703+/* end confdefs.h. */ 3704+#include <math.h> 3705+int 3706+main () 3707+{ 3708+ _sincosf(0, 0, 0); 3709+ ; 3710+ return 0; 3711+} 3712+_ACEOF 3713+if ac_fn_cxx_try_compile "$LINENO"; then : 3714+ glibcxx_cv_func__sincosf_use=yes 3715+else 3716+ glibcxx_cv_func__sincosf_use=no 3717+fi 3718+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3719+ ac_ext=c 3720+ac_cpp='$CPP $CPPFLAGS' 3721+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3722+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3723+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3724+ 3725+ 3726+fi 3727+ 3728+ fi 3729+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__sincosf_use" >&5 3730+$as_echo "$glibcxx_cv_func__sincosf_use" >&6; } 3731+ 3732+ if test x$glibcxx_cv_func__sincosf_use = x"yes"; then 3733+ for ac_func in _sincosf 3734+do : 3735+ ac_fn_c_check_func "$LINENO" "_sincosf" "ac_cv_func__sincosf" 3736+if test "x$ac_cv_func__sincosf" = x""yes; then : 3737+ cat >>confdefs.h <<_ACEOF 3738+#define HAVE__SINCOSF 1 3739+_ACEOF 3740+ 3741+fi 3742+done 3743+ 3744+ fi 3745+ fi 3746+ 3747+ 3748+ 3749+ 3750+ 3751+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for finitef declaration" >&5 3752+$as_echo_n "checking for finitef declaration... " >&6; } 3753+ if test x${glibcxx_cv_func_finitef_use+set} != xset; then 3754+ if test "${glibcxx_cv_func_finitef_use+set}" = set; then : 3755+ $as_echo_n "(cached) " >&6 3756+else 3757+ 3758+ 3759+ ac_ext=cpp 3760+ac_cpp='$CXXCPP $CPPFLAGS' 3761+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3762+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3763+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3764+ 3765+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3766+/* end confdefs.h. */ 3767+#include <math.h> 3768+ #ifdef HAVE_IEEEFP_H 3769+ #include <ieeefp.h> 3770+ #endif 3771+ 3772+int 3773+main () 3774+{ 3775+ finitef(0); 3776+ ; 3777+ return 0; 3778+} 3779+_ACEOF 3780+if ac_fn_cxx_try_compile "$LINENO"; then : 3781+ glibcxx_cv_func_finitef_use=yes 3782+else 3783+ glibcxx_cv_func_finitef_use=no 3784+fi 3785+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3786+ ac_ext=c 3787+ac_cpp='$CPP $CPPFLAGS' 3788+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3789+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3790+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3791+ 3792+ 3793+fi 3794+ 3795+ fi 3796+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_finitef_use" >&5 3797+$as_echo "$glibcxx_cv_func_finitef_use" >&6; } 3798+ 3799+ if test x$glibcxx_cv_func_finitef_use = x"yes"; then 3800+ for ac_func in finitef 3801+do : 3802+ ac_fn_c_check_func "$LINENO" "finitef" "ac_cv_func_finitef" 3803+if test "x$ac_cv_func_finitef" = x""yes; then : 3804+ cat >>confdefs.h <<_ACEOF 3805+#define HAVE_FINITEF 1 3806+_ACEOF 3807+ 3808+fi 3809+done 3810+ 3811+ else 3812+ 3813+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _finitef declaration" >&5 3814+$as_echo_n "checking for _finitef declaration... " >&6; } 3815+ if test x${glibcxx_cv_func__finitef_use+set} != xset; then 3816+ if test "${glibcxx_cv_func__finitef_use+set}" = set; then : 3817+ $as_echo_n "(cached) " >&6 3818+else 3819+ 3820+ 3821+ ac_ext=cpp 3822+ac_cpp='$CXXCPP $CPPFLAGS' 3823+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3824+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3825+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3826+ 3827+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3828+/* end confdefs.h. */ 3829+#include <math.h> 3830+ #ifdef HAVE_IEEEFP_H 3831+ #include <ieeefp.h> 3832+ #endif 3833+ 3834+int 3835+main () 3836+{ 3837+ _finitef(0); 3838+ ; 3839+ return 0; 3840+} 3841+_ACEOF 3842+if ac_fn_cxx_try_compile "$LINENO"; then : 3843+ glibcxx_cv_func__finitef_use=yes 3844+else 3845+ glibcxx_cv_func__finitef_use=no 3846+fi 3847+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3848+ ac_ext=c 3849+ac_cpp='$CPP $CPPFLAGS' 3850+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3851+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3852+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3853+ 3854+ 3855+fi 3856+ 3857+ fi 3858+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__finitef_use" >&5 3859+$as_echo "$glibcxx_cv_func__finitef_use" >&6; } 3860+ 3861+ if test x$glibcxx_cv_func__finitef_use = x"yes"; then 3862+ for ac_func in _finitef 3863+do : 3864+ ac_fn_c_check_func "$LINENO" "_finitef" "ac_cv_func__finitef" 3865+if test "x$ac_cv_func__finitef" = x""yes; then : 3866+ cat >>confdefs.h <<_ACEOF 3867+#define HAVE__FINITEF 1 3868+_ACEOF 3869+ 3870+fi 3871+done 3872+ 3873+ fi 3874+ fi 3875+ 3876+ 3877+ 3878+ 3879+ 3880+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for long double trig functions" >&5 3881+$as_echo_n "checking for long double trig functions... " >&6; } 3882+ if test "${glibcxx_cv_func_long_double_trig_use+set}" = set; then : 3883+ $as_echo_n "(cached) " >&6 3884+else 3885+ 3886+ 3887+ ac_ext=cpp 3888+ac_cpp='$CXXCPP $CPPFLAGS' 3889+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3890+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3891+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3892+ 3893+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3894+/* end confdefs.h. */ 3895+#include <math.h> 3896+int 3897+main () 3898+{ 3899+acosl (0); asinl (0); atanl (0); cosl (0); sinl (0); tanl (0); coshl (0); sinhl (0); tanhl (0); 3900+ ; 3901+ return 0; 3902+} 3903+_ACEOF 3904+if ac_fn_cxx_try_compile "$LINENO"; then : 3905+ glibcxx_cv_func_long_double_trig_use=yes 3906+else 3907+ glibcxx_cv_func_long_double_trig_use=no 3908+fi 3909+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3910+ ac_ext=c 3911+ac_cpp='$CPP $CPPFLAGS' 3912+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3913+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3914+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3915+ 3916+fi 3917+ 3918+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_long_double_trig_use" >&5 3919+$as_echo "$glibcxx_cv_func_long_double_trig_use" >&6; } 3920+ if test x$glibcxx_cv_func_long_double_trig_use = x"yes"; then 3921+ for ac_func in acosl asinl atanl cosl sinl tanl coshl sinhl tanhl 3922+do : 3923+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 3924+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 3925+eval as_val=\$$as_ac_var 3926+ if test "x$as_val" = x""yes; then : 3927+ cat >>confdefs.h <<_ACEOF 3928+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 3929+_ACEOF 3930+ 3931+fi 3932+done 3933+ 3934+ else 3935+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _long double trig functions" >&5 3936+$as_echo_n "checking for _long double trig functions... " >&6; } 3937+ if test "${glibcxx_cv_func__long_double_trig_use+set}" = set; then : 3938+ $as_echo_n "(cached) " >&6 3939+else 3940+ 3941+ 3942+ ac_ext=cpp 3943+ac_cpp='$CXXCPP $CPPFLAGS' 3944+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3945+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3946+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 3947+ 3948+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 3949+/* end confdefs.h. */ 3950+#include <math.h> 3951+int 3952+main () 3953+{ 3954+_acosl (0); _asinl (0); _atanl (0); _cosl (0); _sinl (0); _tanl (0); _coshl (0); _sinhl (0); _tanhl (0); 3955+ ; 3956+ return 0; 3957+} 3958+_ACEOF 3959+if ac_fn_cxx_try_compile "$LINENO"; then : 3960+ glibcxx_cv_func__long_double_trig_use=yes 3961+else 3962+ glibcxx_cv_func__long_double_trig_use=no 3963+fi 3964+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 3965+ ac_ext=c 3966+ac_cpp='$CPP $CPPFLAGS' 3967+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 3968+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 3969+ac_compiler_gnu=$ac_cv_c_compiler_gnu 3970+ 3971+fi 3972+ 3973+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__long_double_trig_use" >&5 3974+$as_echo "$glibcxx_cv_func__long_double_trig_use" >&6; } 3975+ if test x$glibcxx_cv_func__long_double_trig_use = x"yes"; then 3976+ for ac_func in _acosl _asinl _atanl _cosl _sinl _tanl _coshl _sinhl _tanhl 3977+do : 3978+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 3979+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 3980+eval as_val=\$$as_ac_var 3981+ if test "x$as_val" = x""yes; then : 3982+ cat >>confdefs.h <<_ACEOF 3983+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 3984+_ACEOF 3985+ 3986+fi 3987+done 3988+ 3989+ fi 3990+ fi 3991+ 3992+ 3993+ 3994+ 3995+ 3996+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for long double round functions" >&5 3997+$as_echo_n "checking for long double round functions... " >&6; } 3998+ if test "${glibcxx_cv_func_long_double_round_use+set}" = set; then : 3999+ $as_echo_n "(cached) " >&6 4000+else 4001+ 4002+ 4003+ ac_ext=cpp 4004+ac_cpp='$CXXCPP $CPPFLAGS' 4005+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4006+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4007+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4008+ 4009+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4010+/* end confdefs.h. */ 4011+#include <math.h> 4012+int 4013+main () 4014+{ 4015+ceill (0); floorl (0); 4016+ ; 4017+ return 0; 4018+} 4019+_ACEOF 4020+if ac_fn_cxx_try_compile "$LINENO"; then : 4021+ glibcxx_cv_func_long_double_round_use=yes 4022+else 4023+ glibcxx_cv_func_long_double_round_use=no 4024+fi 4025+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4026+ ac_ext=c 4027+ac_cpp='$CPP $CPPFLAGS' 4028+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4029+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4030+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4031+ 4032+fi 4033+ 4034+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_long_double_round_use" >&5 4035+$as_echo "$glibcxx_cv_func_long_double_round_use" >&6; } 4036+ if test x$glibcxx_cv_func_long_double_round_use = x"yes"; then 4037+ for ac_func in ceill floorl 4038+do : 4039+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 4040+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 4041+eval as_val=\$$as_ac_var 4042+ if test "x$as_val" = x""yes; then : 4043+ cat >>confdefs.h <<_ACEOF 4044+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 4045+_ACEOF 4046+ 4047+fi 4048+done 4049+ 4050+ else 4051+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _long double round functions" >&5 4052+$as_echo_n "checking for _long double round functions... " >&6; } 4053+ if test "${glibcxx_cv_func__long_double_round_use+set}" = set; then : 4054+ $as_echo_n "(cached) " >&6 4055+else 4056+ 4057+ 4058+ ac_ext=cpp 4059+ac_cpp='$CXXCPP $CPPFLAGS' 4060+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4061+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4062+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4063+ 4064+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4065+/* end confdefs.h. */ 4066+#include <math.h> 4067+int 4068+main () 4069+{ 4070+_ceill (0); _floorl (0); 4071+ ; 4072+ return 0; 4073+} 4074+_ACEOF 4075+if ac_fn_cxx_try_compile "$LINENO"; then : 4076+ glibcxx_cv_func__long_double_round_use=yes 4077+else 4078+ glibcxx_cv_func__long_double_round_use=no 4079+fi 4080+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4081+ ac_ext=c 4082+ac_cpp='$CPP $CPPFLAGS' 4083+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4084+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4085+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4086+ 4087+fi 4088+ 4089+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__long_double_round_use" >&5 4090+$as_echo "$glibcxx_cv_func__long_double_round_use" >&6; } 4091+ if test x$glibcxx_cv_func__long_double_round_use = x"yes"; then 4092+ for ac_func in _ceill _floorl 4093+do : 4094+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` 4095+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" 4096+eval as_val=\$$as_ac_var 4097+ if test "x$as_val" = x""yes; then : 4098+ cat >>confdefs.h <<_ACEOF 4099+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 4100+_ACEOF 4101+ 4102+fi 4103+done 4104+ 4105+ fi 4106+ fi 4107+ 4108+ 4109+ 4110+ 4111+ 4112+ 4113+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isnanl declaration" >&5 4114+$as_echo_n "checking for isnanl declaration... " >&6; } 4115+ if test x${glibcxx_cv_func_isnanl_use+set} != xset; then 4116+ if test "${glibcxx_cv_func_isnanl_use+set}" = set; then : 4117+ $as_echo_n "(cached) " >&6 4118+else 4119+ 4120+ 4121+ ac_ext=cpp 4122+ac_cpp='$CXXCPP $CPPFLAGS' 4123+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4124+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4125+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4126+ 4127+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4128+/* end confdefs.h. */ 4129+#include <math.h> 4130+ #ifdef HAVE_IEEEFP_H 4131+ #include <ieeefp.h> 4132+ #endif 4133+ 4134+int 4135+main () 4136+{ 4137+ isnanl(0); 4138+ ; 4139+ return 0; 4140+} 4141+_ACEOF 4142+if ac_fn_cxx_try_compile "$LINENO"; then : 4143+ glibcxx_cv_func_isnanl_use=yes 4144+else 4145+ glibcxx_cv_func_isnanl_use=no 4146+fi 4147+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4148+ ac_ext=c 4149+ac_cpp='$CPP $CPPFLAGS' 4150+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4151+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4152+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4153+ 4154+ 4155+fi 4156+ 4157+ fi 4158+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isnanl_use" >&5 4159+$as_echo "$glibcxx_cv_func_isnanl_use" >&6; } 4160+ 4161+ if test x$glibcxx_cv_func_isnanl_use = x"yes"; then 4162+ for ac_func in isnanl 4163+do : 4164+ ac_fn_c_check_func "$LINENO" "isnanl" "ac_cv_func_isnanl" 4165+if test "x$ac_cv_func_isnanl" = x""yes; then : 4166+ cat >>confdefs.h <<_ACEOF 4167+#define HAVE_ISNANL 1 4168+_ACEOF 4169+ 4170+fi 4171+done 4172+ 4173+ else 4174+ 4175+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isnanl declaration" >&5 4176+$as_echo_n "checking for _isnanl declaration... " >&6; } 4177+ if test x${glibcxx_cv_func__isnanl_use+set} != xset; then 4178+ if test "${glibcxx_cv_func__isnanl_use+set}" = set; then : 4179+ $as_echo_n "(cached) " >&6 4180+else 4181+ 4182+ 4183+ ac_ext=cpp 4184+ac_cpp='$CXXCPP $CPPFLAGS' 4185+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4186+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4187+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4188+ 4189+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4190+/* end confdefs.h. */ 4191+#include <math.h> 4192+ #ifdef HAVE_IEEEFP_H 4193+ #include <ieeefp.h> 4194+ #endif 4195+ 4196+int 4197+main () 4198+{ 4199+ _isnanl(0); 4200+ ; 4201+ return 0; 4202+} 4203+_ACEOF 4204+if ac_fn_cxx_try_compile "$LINENO"; then : 4205+ glibcxx_cv_func__isnanl_use=yes 4206+else 4207+ glibcxx_cv_func__isnanl_use=no 4208+fi 4209+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4210+ ac_ext=c 4211+ac_cpp='$CPP $CPPFLAGS' 4212+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4213+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4214+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4215+ 4216+ 4217+fi 4218+ 4219+ fi 4220+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isnanl_use" >&5 4221+$as_echo "$glibcxx_cv_func__isnanl_use" >&6; } 4222+ 4223+ if test x$glibcxx_cv_func__isnanl_use = x"yes"; then 4224+ for ac_func in _isnanl 4225+do : 4226+ ac_fn_c_check_func "$LINENO" "_isnanl" "ac_cv_func__isnanl" 4227+if test "x$ac_cv_func__isnanl" = x""yes; then : 4228+ cat >>confdefs.h <<_ACEOF 4229+#define HAVE__ISNANL 1 4230+_ACEOF 4231+ 4232+fi 4233+done 4234+ 4235+ fi 4236+ fi 4237+ 4238+ 4239+ 4240+ 4241+ 4242+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for isinfl declaration" >&5 4243+$as_echo_n "checking for isinfl declaration... " >&6; } 4244+ if test x${glibcxx_cv_func_isinfl_use+set} != xset; then 4245+ if test "${glibcxx_cv_func_isinfl_use+set}" = set; then : 4246+ $as_echo_n "(cached) " >&6 4247+else 4248+ 4249+ 4250+ ac_ext=cpp 4251+ac_cpp='$CXXCPP $CPPFLAGS' 4252+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4253+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4254+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4255+ 4256+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4257+/* end confdefs.h. */ 4258+#include <math.h> 4259+ #ifdef HAVE_IEEEFP_H 4260+ #include <ieeefp.h> 4261+ #endif 4262+ 4263+int 4264+main () 4265+{ 4266+ isinfl(0); 4267+ ; 4268+ return 0; 4269+} 4270+_ACEOF 4271+if ac_fn_cxx_try_compile "$LINENO"; then : 4272+ glibcxx_cv_func_isinfl_use=yes 4273+else 4274+ glibcxx_cv_func_isinfl_use=no 4275+fi 4276+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4277+ ac_ext=c 4278+ac_cpp='$CPP $CPPFLAGS' 4279+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4280+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4281+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4282+ 4283+ 4284+fi 4285+ 4286+ fi 4287+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_isinfl_use" >&5 4288+$as_echo "$glibcxx_cv_func_isinfl_use" >&6; } 4289+ 4290+ if test x$glibcxx_cv_func_isinfl_use = x"yes"; then 4291+ for ac_func in isinfl 4292+do : 4293+ ac_fn_c_check_func "$LINENO" "isinfl" "ac_cv_func_isinfl" 4294+if test "x$ac_cv_func_isinfl" = x""yes; then : 4295+ cat >>confdefs.h <<_ACEOF 4296+#define HAVE_ISINFL 1 4297+_ACEOF 4298+ 4299+fi 4300+done 4301+ 4302+ else 4303+ 4304+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _isinfl declaration" >&5 4305+$as_echo_n "checking for _isinfl declaration... " >&6; } 4306+ if test x${glibcxx_cv_func__isinfl_use+set} != xset; then 4307+ if test "${glibcxx_cv_func__isinfl_use+set}" = set; then : 4308+ $as_echo_n "(cached) " >&6 4309+else 4310+ 4311+ 4312+ ac_ext=cpp 4313+ac_cpp='$CXXCPP $CPPFLAGS' 4314+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4315+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4316+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4317+ 4318+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4319+/* end confdefs.h. */ 4320+#include <math.h> 4321+ #ifdef HAVE_IEEEFP_H 4322+ #include <ieeefp.h> 4323+ #endif 4324+ 4325+int 4326+main () 4327+{ 4328+ _isinfl(0); 4329+ ; 4330+ return 0; 4331+} 4332+_ACEOF 4333+if ac_fn_cxx_try_compile "$LINENO"; then : 4334+ glibcxx_cv_func__isinfl_use=yes 4335+else 4336+ glibcxx_cv_func__isinfl_use=no 4337+fi 4338+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4339+ ac_ext=c 4340+ac_cpp='$CPP $CPPFLAGS' 4341+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4342+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4343+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4344+ 4345+ 4346+fi 4347+ 4348+ fi 4349+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__isinfl_use" >&5 4350+$as_echo "$glibcxx_cv_func__isinfl_use" >&6; } 4351+ 4352+ if test x$glibcxx_cv_func__isinfl_use = x"yes"; then 4353+ for ac_func in _isinfl 4354+do : 4355+ ac_fn_c_check_func "$LINENO" "_isinfl" "ac_cv_func__isinfl" 4356+if test "x$ac_cv_func__isinfl" = x""yes; then : 4357+ cat >>confdefs.h <<_ACEOF 4358+#define HAVE__ISINFL 1 4359+_ACEOF 4360+ 4361+fi 4362+done 4363+ 4364+ fi 4365+ fi 4366+ 4367+ 4368+ 4369+ 4370+ 4371+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for atan2l declaration" >&5 4372+$as_echo_n "checking for atan2l declaration... " >&6; } 4373+ if test x${glibcxx_cv_func_atan2l_use+set} != xset; then 4374+ if test "${glibcxx_cv_func_atan2l_use+set}" = set; then : 4375+ $as_echo_n "(cached) " >&6 4376+else 4377+ 4378+ 4379+ ac_ext=cpp 4380+ac_cpp='$CXXCPP $CPPFLAGS' 4381+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4382+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4383+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4384+ 4385+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4386+/* end confdefs.h. */ 4387+#include <math.h> 4388+int 4389+main () 4390+{ 4391+ atan2l(0, 0); 4392+ ; 4393+ return 0; 4394+} 4395+_ACEOF 4396+if ac_fn_cxx_try_compile "$LINENO"; then : 4397+ glibcxx_cv_func_atan2l_use=yes 4398+else 4399+ glibcxx_cv_func_atan2l_use=no 4400+fi 4401+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4402+ ac_ext=c 4403+ac_cpp='$CPP $CPPFLAGS' 4404+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4405+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4406+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4407+ 4408+ 4409+fi 4410+ 4411+ fi 4412+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_atan2l_use" >&5 4413+$as_echo "$glibcxx_cv_func_atan2l_use" >&6; } 4414+ 4415+ if test x$glibcxx_cv_func_atan2l_use = x"yes"; then 4416+ for ac_func in atan2l 4417+do : 4418+ ac_fn_c_check_func "$LINENO" "atan2l" "ac_cv_func_atan2l" 4419+if test "x$ac_cv_func_atan2l" = x""yes; then : 4420+ cat >>confdefs.h <<_ACEOF 4421+#define HAVE_ATAN2L 1 4422+_ACEOF 4423+ 4424+fi 4425+done 4426+ 4427+ else 4428+ 4429+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _atan2l declaration" >&5 4430+$as_echo_n "checking for _atan2l declaration... " >&6; } 4431+ if test x${glibcxx_cv_func__atan2l_use+set} != xset; then 4432+ if test "${glibcxx_cv_func__atan2l_use+set}" = set; then : 4433+ $as_echo_n "(cached) " >&6 4434+else 4435+ 4436+ 4437+ ac_ext=cpp 4438+ac_cpp='$CXXCPP $CPPFLAGS' 4439+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4440+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4441+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4442+ 4443+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4444+/* end confdefs.h. */ 4445+#include <math.h> 4446+int 4447+main () 4448+{ 4449+ _atan2l(0, 0); 4450+ ; 4451+ return 0; 4452+} 4453+_ACEOF 4454+if ac_fn_cxx_try_compile "$LINENO"; then : 4455+ glibcxx_cv_func__atan2l_use=yes 4456+else 4457+ glibcxx_cv_func__atan2l_use=no 4458+fi 4459+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4460+ ac_ext=c 4461+ac_cpp='$CPP $CPPFLAGS' 4462+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4463+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4464+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4465+ 4466+ 4467+fi 4468+ 4469+ fi 4470+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__atan2l_use" >&5 4471+$as_echo "$glibcxx_cv_func__atan2l_use" >&6; } 4472+ 4473+ if test x$glibcxx_cv_func__atan2l_use = x"yes"; then 4474+ for ac_func in _atan2l 4475+do : 4476+ ac_fn_c_check_func "$LINENO" "_atan2l" "ac_cv_func__atan2l" 4477+if test "x$ac_cv_func__atan2l" = x""yes; then : 4478+ cat >>confdefs.h <<_ACEOF 4479+#define HAVE__ATAN2L 1 4480+_ACEOF 4481+ 4482+fi 4483+done 4484+ 4485+ fi 4486+ fi 4487+ 4488+ 4489+ 4490+ 4491+ 4492+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for expl declaration" >&5 4493+$as_echo_n "checking for expl declaration... " >&6; } 4494+ if test x${glibcxx_cv_func_expl_use+set} != xset; then 4495+ if test "${glibcxx_cv_func_expl_use+set}" = set; then : 4496+ $as_echo_n "(cached) " >&6 4497+else 4498+ 4499+ 4500+ ac_ext=cpp 4501+ac_cpp='$CXXCPP $CPPFLAGS' 4502+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4503+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4504+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4505+ 4506+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4507+/* end confdefs.h. */ 4508+#include <math.h> 4509+ #ifdef HAVE_IEEEFP_H 4510+ #include <ieeefp.h> 4511+ #endif 4512+ 4513+int 4514+main () 4515+{ 4516+ expl(0); 4517+ ; 4518+ return 0; 4519+} 4520+_ACEOF 4521+if ac_fn_cxx_try_compile "$LINENO"; then : 4522+ glibcxx_cv_func_expl_use=yes 4523+else 4524+ glibcxx_cv_func_expl_use=no 4525+fi 4526+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4527+ ac_ext=c 4528+ac_cpp='$CPP $CPPFLAGS' 4529+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4530+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4531+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4532+ 4533+ 4534+fi 4535+ 4536+ fi 4537+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_expl_use" >&5 4538+$as_echo "$glibcxx_cv_func_expl_use" >&6; } 4539+ 4540+ if test x$glibcxx_cv_func_expl_use = x"yes"; then 4541+ for ac_func in expl 4542+do : 4543+ ac_fn_c_check_func "$LINENO" "expl" "ac_cv_func_expl" 4544+if test "x$ac_cv_func_expl" = x""yes; then : 4545+ cat >>confdefs.h <<_ACEOF 4546+#define HAVE_EXPL 1 4547+_ACEOF 4548+ 4549+fi 4550+done 4551+ 4552+ else 4553+ 4554+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _expl declaration" >&5 4555+$as_echo_n "checking for _expl declaration... " >&6; } 4556+ if test x${glibcxx_cv_func__expl_use+set} != xset; then 4557+ if test "${glibcxx_cv_func__expl_use+set}" = set; then : 4558+ $as_echo_n "(cached) " >&6 4559+else 4560+ 4561+ 4562+ ac_ext=cpp 4563+ac_cpp='$CXXCPP $CPPFLAGS' 4564+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4565+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4566+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4567+ 4568+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4569+/* end confdefs.h. */ 4570+#include <math.h> 4571+ #ifdef HAVE_IEEEFP_H 4572+ #include <ieeefp.h> 4573+ #endif 4574+ 4575+int 4576+main () 4577+{ 4578+ _expl(0); 4579+ ; 4580+ return 0; 4581+} 4582+_ACEOF 4583+if ac_fn_cxx_try_compile "$LINENO"; then : 4584+ glibcxx_cv_func__expl_use=yes 4585+else 4586+ glibcxx_cv_func__expl_use=no 4587+fi 4588+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4589+ ac_ext=c 4590+ac_cpp='$CPP $CPPFLAGS' 4591+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4592+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4593+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4594+ 4595+ 4596+fi 4597+ 4598+ fi 4599+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__expl_use" >&5 4600+$as_echo "$glibcxx_cv_func__expl_use" >&6; } 4601+ 4602+ if test x$glibcxx_cv_func__expl_use = x"yes"; then 4603+ for ac_func in _expl 4604+do : 4605+ ac_fn_c_check_func "$LINENO" "_expl" "ac_cv_func__expl" 4606+if test "x$ac_cv_func__expl" = x""yes; then : 4607+ cat >>confdefs.h <<_ACEOF 4608+#define HAVE__EXPL 1 4609+_ACEOF 4610+ 4611+fi 4612+done 4613+ 4614+ fi 4615+ fi 4616+ 4617+ 4618+ 4619+ 4620+ 4621+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fabsl declaration" >&5 4622+$as_echo_n "checking for fabsl declaration... " >&6; } 4623+ if test x${glibcxx_cv_func_fabsl_use+set} != xset; then 4624+ if test "${glibcxx_cv_func_fabsl_use+set}" = set; then : 4625+ $as_echo_n "(cached) " >&6 4626+else 4627+ 4628+ 4629+ ac_ext=cpp 4630+ac_cpp='$CXXCPP $CPPFLAGS' 4631+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4632+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4633+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4634+ 4635+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4636+/* end confdefs.h. */ 4637+#include <math.h> 4638+ #ifdef HAVE_IEEEFP_H 4639+ #include <ieeefp.h> 4640+ #endif 4641+ 4642+int 4643+main () 4644+{ 4645+ fabsl(0); 4646+ ; 4647+ return 0; 4648+} 4649+_ACEOF 4650+if ac_fn_cxx_try_compile "$LINENO"; then : 4651+ glibcxx_cv_func_fabsl_use=yes 4652+else 4653+ glibcxx_cv_func_fabsl_use=no 4654+fi 4655+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4656+ ac_ext=c 4657+ac_cpp='$CPP $CPPFLAGS' 4658+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4659+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4660+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4661+ 4662+ 4663+fi 4664+ 4665+ fi 4666+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_fabsl_use" >&5 4667+$as_echo "$glibcxx_cv_func_fabsl_use" >&6; } 4668+ 4669+ if test x$glibcxx_cv_func_fabsl_use = x"yes"; then 4670+ for ac_func in fabsl 4671+do : 4672+ ac_fn_c_check_func "$LINENO" "fabsl" "ac_cv_func_fabsl" 4673+if test "x$ac_cv_func_fabsl" = x""yes; then : 4674+ cat >>confdefs.h <<_ACEOF 4675+#define HAVE_FABSL 1 4676+_ACEOF 4677+ 4678+fi 4679+done 4680+ 4681+ else 4682+ 4683+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _fabsl declaration" >&5 4684+$as_echo_n "checking for _fabsl declaration... " >&6; } 4685+ if test x${glibcxx_cv_func__fabsl_use+set} != xset; then 4686+ if test "${glibcxx_cv_func__fabsl_use+set}" = set; then : 4687+ $as_echo_n "(cached) " >&6 4688+else 4689+ 4690+ 4691+ ac_ext=cpp 4692+ac_cpp='$CXXCPP $CPPFLAGS' 4693+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4694+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4695+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4696+ 4697+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4698+/* end confdefs.h. */ 4699+#include <math.h> 4700+ #ifdef HAVE_IEEEFP_H 4701+ #include <ieeefp.h> 4702+ #endif 4703+ 4704+int 4705+main () 4706+{ 4707+ _fabsl(0); 4708+ ; 4709+ return 0; 4710+} 4711+_ACEOF 4712+if ac_fn_cxx_try_compile "$LINENO"; then : 4713+ glibcxx_cv_func__fabsl_use=yes 4714+else 4715+ glibcxx_cv_func__fabsl_use=no 4716+fi 4717+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4718+ ac_ext=c 4719+ac_cpp='$CPP $CPPFLAGS' 4720+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4721+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4722+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4723+ 4724+ 4725+fi 4726+ 4727+ fi 4728+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__fabsl_use" >&5 4729+$as_echo "$glibcxx_cv_func__fabsl_use" >&6; } 4730+ 4731+ if test x$glibcxx_cv_func__fabsl_use = x"yes"; then 4732+ for ac_func in _fabsl 4733+do : 4734+ ac_fn_c_check_func "$LINENO" "_fabsl" "ac_cv_func__fabsl" 4735+if test "x$ac_cv_func__fabsl" = x""yes; then : 4736+ cat >>confdefs.h <<_ACEOF 4737+#define HAVE__FABSL 1 4738+_ACEOF 4739+ 4740+fi 4741+done 4742+ 4743+ fi 4744+ fi 4745+ 4746+ 4747+ 4748+ 4749+ 4750+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fmodl declaration" >&5 4751+$as_echo_n "checking for fmodl declaration... " >&6; } 4752+ if test x${glibcxx_cv_func_fmodl_use+set} != xset; then 4753+ if test "${glibcxx_cv_func_fmodl_use+set}" = set; then : 4754+ $as_echo_n "(cached) " >&6 4755+else 4756+ 4757+ 4758+ ac_ext=cpp 4759+ac_cpp='$CXXCPP $CPPFLAGS' 4760+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4761+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4762+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4763+ 4764+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4765+/* end confdefs.h. */ 4766+#include <math.h> 4767+int 4768+main () 4769+{ 4770+ fmodl(0, 0); 4771+ ; 4772+ return 0; 4773+} 4774+_ACEOF 4775+if ac_fn_cxx_try_compile "$LINENO"; then : 4776+ glibcxx_cv_func_fmodl_use=yes 4777+else 4778+ glibcxx_cv_func_fmodl_use=no 4779+fi 4780+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4781+ ac_ext=c 4782+ac_cpp='$CPP $CPPFLAGS' 4783+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4784+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4785+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4786+ 4787+ 4788+fi 4789+ 4790+ fi 4791+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_fmodl_use" >&5 4792+$as_echo "$glibcxx_cv_func_fmodl_use" >&6; } 4793+ 4794+ if test x$glibcxx_cv_func_fmodl_use = x"yes"; then 4795+ for ac_func in fmodl 4796+do : 4797+ ac_fn_c_check_func "$LINENO" "fmodl" "ac_cv_func_fmodl" 4798+if test "x$ac_cv_func_fmodl" = x""yes; then : 4799+ cat >>confdefs.h <<_ACEOF 4800+#define HAVE_FMODL 1 4801+_ACEOF 4802+ 4803+fi 4804+done 4805+ 4806+ else 4807+ 4808+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _fmodl declaration" >&5 4809+$as_echo_n "checking for _fmodl declaration... " >&6; } 4810+ if test x${glibcxx_cv_func__fmodl_use+set} != xset; then 4811+ if test "${glibcxx_cv_func__fmodl_use+set}" = set; then : 4812+ $as_echo_n "(cached) " >&6 4813+else 4814+ 4815+ 4816+ ac_ext=cpp 4817+ac_cpp='$CXXCPP $CPPFLAGS' 4818+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4819+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4820+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4821+ 4822+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4823+/* end confdefs.h. */ 4824+#include <math.h> 4825+int 4826+main () 4827+{ 4828+ _fmodl(0, 0); 4829+ ; 4830+ return 0; 4831+} 4832+_ACEOF 4833+if ac_fn_cxx_try_compile "$LINENO"; then : 4834+ glibcxx_cv_func__fmodl_use=yes 4835+else 4836+ glibcxx_cv_func__fmodl_use=no 4837+fi 4838+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4839+ ac_ext=c 4840+ac_cpp='$CPP $CPPFLAGS' 4841+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4842+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4843+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4844+ 4845+ 4846+fi 4847+ 4848+ fi 4849+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__fmodl_use" >&5 4850+$as_echo "$glibcxx_cv_func__fmodl_use" >&6; } 4851+ 4852+ if test x$glibcxx_cv_func__fmodl_use = x"yes"; then 4853+ for ac_func in _fmodl 4854+do : 4855+ ac_fn_c_check_func "$LINENO" "_fmodl" "ac_cv_func__fmodl" 4856+if test "x$ac_cv_func__fmodl" = x""yes; then : 4857+ cat >>confdefs.h <<_ACEOF 4858+#define HAVE__FMODL 1 4859+_ACEOF 4860+ 4861+fi 4862+done 4863+ 4864+ fi 4865+ fi 4866+ 4867+ 4868+ 4869+ 4870+ 4871+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for frexpl declaration" >&5 4872+$as_echo_n "checking for frexpl declaration... " >&6; } 4873+ if test x${glibcxx_cv_func_frexpl_use+set} != xset; then 4874+ if test "${glibcxx_cv_func_frexpl_use+set}" = set; then : 4875+ $as_echo_n "(cached) " >&6 4876+else 4877+ 4878+ 4879+ ac_ext=cpp 4880+ac_cpp='$CXXCPP $CPPFLAGS' 4881+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4882+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4883+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4884+ 4885+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4886+/* end confdefs.h. */ 4887+#include <math.h> 4888+int 4889+main () 4890+{ 4891+ frexpl(0, 0); 4892+ ; 4893+ return 0; 4894+} 4895+_ACEOF 4896+if ac_fn_cxx_try_compile "$LINENO"; then : 4897+ glibcxx_cv_func_frexpl_use=yes 4898+else 4899+ glibcxx_cv_func_frexpl_use=no 4900+fi 4901+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4902+ ac_ext=c 4903+ac_cpp='$CPP $CPPFLAGS' 4904+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4905+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4906+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4907+ 4908+ 4909+fi 4910+ 4911+ fi 4912+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_frexpl_use" >&5 4913+$as_echo "$glibcxx_cv_func_frexpl_use" >&6; } 4914+ 4915+ if test x$glibcxx_cv_func_frexpl_use = x"yes"; then 4916+ for ac_func in frexpl 4917+do : 4918+ ac_fn_c_check_func "$LINENO" "frexpl" "ac_cv_func_frexpl" 4919+if test "x$ac_cv_func_frexpl" = x""yes; then : 4920+ cat >>confdefs.h <<_ACEOF 4921+#define HAVE_FREXPL 1 4922+_ACEOF 4923+ 4924+fi 4925+done 4926+ 4927+ else 4928+ 4929+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _frexpl declaration" >&5 4930+$as_echo_n "checking for _frexpl declaration... " >&6; } 4931+ if test x${glibcxx_cv_func__frexpl_use+set} != xset; then 4932+ if test "${glibcxx_cv_func__frexpl_use+set}" = set; then : 4933+ $as_echo_n "(cached) " >&6 4934+else 4935+ 4936+ 4937+ ac_ext=cpp 4938+ac_cpp='$CXXCPP $CPPFLAGS' 4939+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4940+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4941+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 4942+ 4943+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 4944+/* end confdefs.h. */ 4945+#include <math.h> 4946+int 4947+main () 4948+{ 4949+ _frexpl(0, 0); 4950+ ; 4951+ return 0; 4952+} 4953+_ACEOF 4954+if ac_fn_cxx_try_compile "$LINENO"; then : 4955+ glibcxx_cv_func__frexpl_use=yes 4956+else 4957+ glibcxx_cv_func__frexpl_use=no 4958+fi 4959+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 4960+ ac_ext=c 4961+ac_cpp='$CPP $CPPFLAGS' 4962+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 4963+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 4964+ac_compiler_gnu=$ac_cv_c_compiler_gnu 4965+ 4966+ 4967+fi 4968+ 4969+ fi 4970+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__frexpl_use" >&5 4971+$as_echo "$glibcxx_cv_func__frexpl_use" >&6; } 4972+ 4973+ if test x$glibcxx_cv_func__frexpl_use = x"yes"; then 4974+ for ac_func in _frexpl 4975+do : 4976+ ac_fn_c_check_func "$LINENO" "_frexpl" "ac_cv_func__frexpl" 4977+if test "x$ac_cv_func__frexpl" = x""yes; then : 4978+ cat >>confdefs.h <<_ACEOF 4979+#define HAVE__FREXPL 1 4980+_ACEOF 4981+ 4982+fi 4983+done 4984+ 4985+ fi 4986+ fi 4987+ 4988+ 4989+ 4990+ 4991+ 4992+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for hypotl declaration" >&5 4993+$as_echo_n "checking for hypotl declaration... " >&6; } 4994+ if test x${glibcxx_cv_func_hypotl_use+set} != xset; then 4995+ if test "${glibcxx_cv_func_hypotl_use+set}" = set; then : 4996+ $as_echo_n "(cached) " >&6 4997+else 4998+ 4999+ 5000+ ac_ext=cpp 5001+ac_cpp='$CXXCPP $CPPFLAGS' 5002+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5003+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5004+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5005+ 5006+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5007+/* end confdefs.h. */ 5008+#include <math.h> 5009+int 5010+main () 5011+{ 5012+ hypotl(0, 0); 5013+ ; 5014+ return 0; 5015+} 5016+_ACEOF 5017+if ac_fn_cxx_try_compile "$LINENO"; then : 5018+ glibcxx_cv_func_hypotl_use=yes 5019+else 5020+ glibcxx_cv_func_hypotl_use=no 5021+fi 5022+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5023+ ac_ext=c 5024+ac_cpp='$CPP $CPPFLAGS' 5025+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5026+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5027+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5028+ 5029+ 5030+fi 5031+ 5032+ fi 5033+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_hypotl_use" >&5 5034+$as_echo "$glibcxx_cv_func_hypotl_use" >&6; } 5035+ 5036+ if test x$glibcxx_cv_func_hypotl_use = x"yes"; then 5037+ for ac_func in hypotl 5038+do : 5039+ ac_fn_c_check_func "$LINENO" "hypotl" "ac_cv_func_hypotl" 5040+if test "x$ac_cv_func_hypotl" = x""yes; then : 5041+ cat >>confdefs.h <<_ACEOF 5042+#define HAVE_HYPOTL 1 5043+_ACEOF 5044+ 5045+fi 5046+done 5047+ 5048+ else 5049+ 5050+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _hypotl declaration" >&5 5051+$as_echo_n "checking for _hypotl declaration... " >&6; } 5052+ if test x${glibcxx_cv_func__hypotl_use+set} != xset; then 5053+ if test "${glibcxx_cv_func__hypotl_use+set}" = set; then : 5054+ $as_echo_n "(cached) " >&6 5055+else 5056+ 5057+ 5058+ ac_ext=cpp 5059+ac_cpp='$CXXCPP $CPPFLAGS' 5060+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5061+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5062+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5063+ 5064+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5065+/* end confdefs.h. */ 5066+#include <math.h> 5067+int 5068+main () 5069+{ 5070+ _hypotl(0, 0); 5071+ ; 5072+ return 0; 5073+} 5074+_ACEOF 5075+if ac_fn_cxx_try_compile "$LINENO"; then : 5076+ glibcxx_cv_func__hypotl_use=yes 5077+else 5078+ glibcxx_cv_func__hypotl_use=no 5079+fi 5080+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5081+ ac_ext=c 5082+ac_cpp='$CPP $CPPFLAGS' 5083+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5084+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5085+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5086+ 5087+ 5088+fi 5089+ 5090+ fi 5091+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__hypotl_use" >&5 5092+$as_echo "$glibcxx_cv_func__hypotl_use" >&6; } 5093+ 5094+ if test x$glibcxx_cv_func__hypotl_use = x"yes"; then 5095+ for ac_func in _hypotl 5096+do : 5097+ ac_fn_c_check_func "$LINENO" "_hypotl" "ac_cv_func__hypotl" 5098+if test "x$ac_cv_func__hypotl" = x""yes; then : 5099+ cat >>confdefs.h <<_ACEOF 5100+#define HAVE__HYPOTL 1 5101+_ACEOF 5102+ 5103+fi 5104+done 5105+ 5106+ fi 5107+ fi 5108+ 5109+ 5110+ 5111+ 5112+ 5113+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldexpl declaration" >&5 5114+$as_echo_n "checking for ldexpl declaration... " >&6; } 5115+ if test x${glibcxx_cv_func_ldexpl_use+set} != xset; then 5116+ if test "${glibcxx_cv_func_ldexpl_use+set}" = set; then : 5117+ $as_echo_n "(cached) " >&6 5118+else 5119+ 5120+ 5121+ ac_ext=cpp 5122+ac_cpp='$CXXCPP $CPPFLAGS' 5123+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5124+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5125+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5126+ 5127+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5128+/* end confdefs.h. */ 5129+#include <math.h> 5130+int 5131+main () 5132+{ 5133+ ldexpl(0, 0); 5134+ ; 5135+ return 0; 5136+} 5137+_ACEOF 5138+if ac_fn_cxx_try_compile "$LINENO"; then : 5139+ glibcxx_cv_func_ldexpl_use=yes 5140+else 5141+ glibcxx_cv_func_ldexpl_use=no 5142+fi 5143+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5144+ ac_ext=c 5145+ac_cpp='$CPP $CPPFLAGS' 5146+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5147+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5148+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5149+ 5150+ 5151+fi 5152+ 5153+ fi 5154+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_ldexpl_use" >&5 5155+$as_echo "$glibcxx_cv_func_ldexpl_use" >&6; } 5156+ 5157+ if test x$glibcxx_cv_func_ldexpl_use = x"yes"; then 5158+ for ac_func in ldexpl 5159+do : 5160+ ac_fn_c_check_func "$LINENO" "ldexpl" "ac_cv_func_ldexpl" 5161+if test "x$ac_cv_func_ldexpl" = x""yes; then : 5162+ cat >>confdefs.h <<_ACEOF 5163+#define HAVE_LDEXPL 1 5164+_ACEOF 5165+ 5166+fi 5167+done 5168+ 5169+ else 5170+ 5171+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _ldexpl declaration" >&5 5172+$as_echo_n "checking for _ldexpl declaration... " >&6; } 5173+ if test x${glibcxx_cv_func__ldexpl_use+set} != xset; then 5174+ if test "${glibcxx_cv_func__ldexpl_use+set}" = set; then : 5175+ $as_echo_n "(cached) " >&6 5176+else 5177+ 5178+ 5179+ ac_ext=cpp 5180+ac_cpp='$CXXCPP $CPPFLAGS' 5181+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5182+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5183+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5184+ 5185+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5186+/* end confdefs.h. */ 5187+#include <math.h> 5188+int 5189+main () 5190+{ 5191+ _ldexpl(0, 0); 5192+ ; 5193+ return 0; 5194+} 5195+_ACEOF 5196+if ac_fn_cxx_try_compile "$LINENO"; then : 5197+ glibcxx_cv_func__ldexpl_use=yes 5198+else 5199+ glibcxx_cv_func__ldexpl_use=no 5200+fi 5201+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5202+ ac_ext=c 5203+ac_cpp='$CPP $CPPFLAGS' 5204+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5205+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5206+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5207+ 5208+ 5209+fi 5210+ 5211+ fi 5212+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__ldexpl_use" >&5 5213+$as_echo "$glibcxx_cv_func__ldexpl_use" >&6; } 5214+ 5215+ if test x$glibcxx_cv_func__ldexpl_use = x"yes"; then 5216+ for ac_func in _ldexpl 5217+do : 5218+ ac_fn_c_check_func "$LINENO" "_ldexpl" "ac_cv_func__ldexpl" 5219+if test "x$ac_cv_func__ldexpl" = x""yes; then : 5220+ cat >>confdefs.h <<_ACEOF 5221+#define HAVE__LDEXPL 1 5222+_ACEOF 5223+ 5224+fi 5225+done 5226+ 5227+ fi 5228+ fi 5229+ 5230+ 5231+ 5232+ 5233+ 5234+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for logl declaration" >&5 5235+$as_echo_n "checking for logl declaration... " >&6; } 5236+ if test x${glibcxx_cv_func_logl_use+set} != xset; then 5237+ if test "${glibcxx_cv_func_logl_use+set}" = set; then : 5238+ $as_echo_n "(cached) " >&6 5239+else 5240+ 5241+ 5242+ ac_ext=cpp 5243+ac_cpp='$CXXCPP $CPPFLAGS' 5244+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5245+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5246+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5247+ 5248+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5249+/* end confdefs.h. */ 5250+#include <math.h> 5251+ #ifdef HAVE_IEEEFP_H 5252+ #include <ieeefp.h> 5253+ #endif 5254+ 5255+int 5256+main () 5257+{ 5258+ logl(0); 5259+ ; 5260+ return 0; 5261+} 5262+_ACEOF 5263+if ac_fn_cxx_try_compile "$LINENO"; then : 5264+ glibcxx_cv_func_logl_use=yes 5265+else 5266+ glibcxx_cv_func_logl_use=no 5267+fi 5268+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5269+ ac_ext=c 5270+ac_cpp='$CPP $CPPFLAGS' 5271+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5272+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5273+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5274+ 5275+ 5276+fi 5277+ 5278+ fi 5279+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_logl_use" >&5 5280+$as_echo "$glibcxx_cv_func_logl_use" >&6; } 5281+ 5282+ if test x$glibcxx_cv_func_logl_use = x"yes"; then 5283+ for ac_func in logl 5284+do : 5285+ ac_fn_c_check_func "$LINENO" "logl" "ac_cv_func_logl" 5286+if test "x$ac_cv_func_logl" = x""yes; then : 5287+ cat >>confdefs.h <<_ACEOF 5288+#define HAVE_LOGL 1 5289+_ACEOF 5290+ 5291+fi 5292+done 5293+ 5294+ else 5295+ 5296+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _logl declaration" >&5 5297+$as_echo_n "checking for _logl declaration... " >&6; } 5298+ if test x${glibcxx_cv_func__logl_use+set} != xset; then 5299+ if test "${glibcxx_cv_func__logl_use+set}" = set; then : 5300+ $as_echo_n "(cached) " >&6 5301+else 5302+ 5303+ 5304+ ac_ext=cpp 5305+ac_cpp='$CXXCPP $CPPFLAGS' 5306+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5307+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5308+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5309+ 5310+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5311+/* end confdefs.h. */ 5312+#include <math.h> 5313+ #ifdef HAVE_IEEEFP_H 5314+ #include <ieeefp.h> 5315+ #endif 5316+ 5317+int 5318+main () 5319+{ 5320+ _logl(0); 5321+ ; 5322+ return 0; 5323+} 5324+_ACEOF 5325+if ac_fn_cxx_try_compile "$LINENO"; then : 5326+ glibcxx_cv_func__logl_use=yes 5327+else 5328+ glibcxx_cv_func__logl_use=no 5329+fi 5330+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5331+ ac_ext=c 5332+ac_cpp='$CPP $CPPFLAGS' 5333+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5334+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5335+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5336+ 5337+ 5338+fi 5339+ 5340+ fi 5341+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__logl_use" >&5 5342+$as_echo "$glibcxx_cv_func__logl_use" >&6; } 5343+ 5344+ if test x$glibcxx_cv_func__logl_use = x"yes"; then 5345+ for ac_func in _logl 5346+do : 5347+ ac_fn_c_check_func "$LINENO" "_logl" "ac_cv_func__logl" 5348+if test "x$ac_cv_func__logl" = x""yes; then : 5349+ cat >>confdefs.h <<_ACEOF 5350+#define HAVE__LOGL 1 5351+_ACEOF 5352+ 5353+fi 5354+done 5355+ 5356+ fi 5357+ fi 5358+ 5359+ 5360+ 5361+ 5362+ 5363+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for log10l declaration" >&5 5364+$as_echo_n "checking for log10l declaration... " >&6; } 5365+ if test x${glibcxx_cv_func_log10l_use+set} != xset; then 5366+ if test "${glibcxx_cv_func_log10l_use+set}" = set; then : 5367+ $as_echo_n "(cached) " >&6 5368+else 5369+ 5370+ 5371+ ac_ext=cpp 5372+ac_cpp='$CXXCPP $CPPFLAGS' 5373+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5374+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5375+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5376+ 5377+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5378+/* end confdefs.h. */ 5379+#include <math.h> 5380+ #ifdef HAVE_IEEEFP_H 5381+ #include <ieeefp.h> 5382+ #endif 5383+ 5384+int 5385+main () 5386+{ 5387+ log10l(0); 5388+ ; 5389+ return 0; 5390+} 5391+_ACEOF 5392+if ac_fn_cxx_try_compile "$LINENO"; then : 5393+ glibcxx_cv_func_log10l_use=yes 5394+else 5395+ glibcxx_cv_func_log10l_use=no 5396+fi 5397+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5398+ ac_ext=c 5399+ac_cpp='$CPP $CPPFLAGS' 5400+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5401+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5402+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5403+ 5404+ 5405+fi 5406+ 5407+ fi 5408+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_log10l_use" >&5 5409+$as_echo "$glibcxx_cv_func_log10l_use" >&6; } 5410+ 5411+ if test x$glibcxx_cv_func_log10l_use = x"yes"; then 5412+ for ac_func in log10l 5413+do : 5414+ ac_fn_c_check_func "$LINENO" "log10l" "ac_cv_func_log10l" 5415+if test "x$ac_cv_func_log10l" = x""yes; then : 5416+ cat >>confdefs.h <<_ACEOF 5417+#define HAVE_LOG10L 1 5418+_ACEOF 5419+ 5420+fi 5421+done 5422+ 5423+ else 5424+ 5425+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _log10l declaration" >&5 5426+$as_echo_n "checking for _log10l declaration... " >&6; } 5427+ if test x${glibcxx_cv_func__log10l_use+set} != xset; then 5428+ if test "${glibcxx_cv_func__log10l_use+set}" = set; then : 5429+ $as_echo_n "(cached) " >&6 5430+else 5431+ 5432+ 5433+ ac_ext=cpp 5434+ac_cpp='$CXXCPP $CPPFLAGS' 5435+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5436+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5437+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5438+ 5439+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5440+/* end confdefs.h. */ 5441+#include <math.h> 5442+ #ifdef HAVE_IEEEFP_H 5443+ #include <ieeefp.h> 5444+ #endif 5445+ 5446+int 5447+main () 5448+{ 5449+ _log10l(0); 5450+ ; 5451+ return 0; 5452+} 5453+_ACEOF 5454+if ac_fn_cxx_try_compile "$LINENO"; then : 5455+ glibcxx_cv_func__log10l_use=yes 5456+else 5457+ glibcxx_cv_func__log10l_use=no 5458+fi 5459+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5460+ ac_ext=c 5461+ac_cpp='$CPP $CPPFLAGS' 5462+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5463+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5464+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5465+ 5466+ 5467+fi 5468+ 5469+ fi 5470+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__log10l_use" >&5 5471+$as_echo "$glibcxx_cv_func__log10l_use" >&6; } 5472+ 5473+ if test x$glibcxx_cv_func__log10l_use = x"yes"; then 5474+ for ac_func in _log10l 5475+do : 5476+ ac_fn_c_check_func "$LINENO" "_log10l" "ac_cv_func__log10l" 5477+if test "x$ac_cv_func__log10l" = x""yes; then : 5478+ cat >>confdefs.h <<_ACEOF 5479+#define HAVE__LOG10L 1 5480+_ACEOF 5481+ 5482+fi 5483+done 5484+ 5485+ fi 5486+ fi 5487+ 5488+ 5489+ 5490+ 5491+ 5492+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for modfl declaration" >&5 5493+$as_echo_n "checking for modfl declaration... " >&6; } 5494+ if test x${glibcxx_cv_func_modfl_use+set} != xset; then 5495+ if test "${glibcxx_cv_func_modfl_use+set}" = set; then : 5496+ $as_echo_n "(cached) " >&6 5497+else 5498+ 5499+ 5500+ ac_ext=cpp 5501+ac_cpp='$CXXCPP $CPPFLAGS' 5502+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5503+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5504+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5505+ 5506+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5507+/* end confdefs.h. */ 5508+#include <math.h> 5509+int 5510+main () 5511+{ 5512+ modfl(0, 0); 5513+ ; 5514+ return 0; 5515+} 5516+_ACEOF 5517+if ac_fn_cxx_try_compile "$LINENO"; then : 5518+ glibcxx_cv_func_modfl_use=yes 5519+else 5520+ glibcxx_cv_func_modfl_use=no 5521+fi 5522+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5523+ ac_ext=c 5524+ac_cpp='$CPP $CPPFLAGS' 5525+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5526+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5527+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5528+ 5529+ 5530+fi 5531+ 5532+ fi 5533+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_modfl_use" >&5 5534+$as_echo "$glibcxx_cv_func_modfl_use" >&6; } 5535+ 5536+ if test x$glibcxx_cv_func_modfl_use = x"yes"; then 5537+ for ac_func in modfl 5538+do : 5539+ ac_fn_c_check_func "$LINENO" "modfl" "ac_cv_func_modfl" 5540+if test "x$ac_cv_func_modfl" = x""yes; then : 5541+ cat >>confdefs.h <<_ACEOF 5542+#define HAVE_MODFL 1 5543+_ACEOF 5544+ 5545+fi 5546+done 5547+ 5548+ else 5549+ 5550+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _modfl declaration" >&5 5551+$as_echo_n "checking for _modfl declaration... " >&6; } 5552+ if test x${glibcxx_cv_func__modfl_use+set} != xset; then 5553+ if test "${glibcxx_cv_func__modfl_use+set}" = set; then : 5554+ $as_echo_n "(cached) " >&6 5555+else 5556+ 5557+ 5558+ ac_ext=cpp 5559+ac_cpp='$CXXCPP $CPPFLAGS' 5560+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5561+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5562+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5563+ 5564+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5565+/* end confdefs.h. */ 5566+#include <math.h> 5567+int 5568+main () 5569+{ 5570+ _modfl(0, 0); 5571+ ; 5572+ return 0; 5573+} 5574+_ACEOF 5575+if ac_fn_cxx_try_compile "$LINENO"; then : 5576+ glibcxx_cv_func__modfl_use=yes 5577+else 5578+ glibcxx_cv_func__modfl_use=no 5579+fi 5580+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5581+ ac_ext=c 5582+ac_cpp='$CPP $CPPFLAGS' 5583+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5584+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5585+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5586+ 5587+ 5588+fi 5589+ 5590+ fi 5591+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__modfl_use" >&5 5592+$as_echo "$glibcxx_cv_func__modfl_use" >&6; } 5593+ 5594+ if test x$glibcxx_cv_func__modfl_use = x"yes"; then 5595+ for ac_func in _modfl 5596+do : 5597+ ac_fn_c_check_func "$LINENO" "_modfl" "ac_cv_func__modfl" 5598+if test "x$ac_cv_func__modfl" = x""yes; then : 5599+ cat >>confdefs.h <<_ACEOF 5600+#define HAVE__MODFL 1 5601+_ACEOF 5602+ 5603+fi 5604+done 5605+ 5606+ fi 5607+ fi 5608+ 5609+ 5610+ 5611+ 5612+ 5613+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for powl declaration" >&5 5614+$as_echo_n "checking for powl declaration... " >&6; } 5615+ if test x${glibcxx_cv_func_powl_use+set} != xset; then 5616+ if test "${glibcxx_cv_func_powl_use+set}" = set; then : 5617+ $as_echo_n "(cached) " >&6 5618+else 5619+ 5620+ 5621+ ac_ext=cpp 5622+ac_cpp='$CXXCPP $CPPFLAGS' 5623+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5624+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5625+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5626+ 5627+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5628+/* end confdefs.h. */ 5629+#include <math.h> 5630+int 5631+main () 5632+{ 5633+ powl(0, 0); 5634+ ; 5635+ return 0; 5636+} 5637+_ACEOF 5638+if ac_fn_cxx_try_compile "$LINENO"; then : 5639+ glibcxx_cv_func_powl_use=yes 5640+else 5641+ glibcxx_cv_func_powl_use=no 5642+fi 5643+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5644+ ac_ext=c 5645+ac_cpp='$CPP $CPPFLAGS' 5646+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5647+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5648+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5649+ 5650+ 5651+fi 5652+ 5653+ fi 5654+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_powl_use" >&5 5655+$as_echo "$glibcxx_cv_func_powl_use" >&6; } 5656+ 5657+ if test x$glibcxx_cv_func_powl_use = x"yes"; then 5658+ for ac_func in powl 5659+do : 5660+ ac_fn_c_check_func "$LINENO" "powl" "ac_cv_func_powl" 5661+if test "x$ac_cv_func_powl" = x""yes; then : 5662+ cat >>confdefs.h <<_ACEOF 5663+#define HAVE_POWL 1 5664+_ACEOF 5665+ 5666+fi 5667+done 5668+ 5669+ else 5670+ 5671+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _powl declaration" >&5 5672+$as_echo_n "checking for _powl declaration... " >&6; } 5673+ if test x${glibcxx_cv_func__powl_use+set} != xset; then 5674+ if test "${glibcxx_cv_func__powl_use+set}" = set; then : 5675+ $as_echo_n "(cached) " >&6 5676+else 5677+ 5678+ 5679+ ac_ext=cpp 5680+ac_cpp='$CXXCPP $CPPFLAGS' 5681+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5682+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5683+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5684+ 5685+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5686+/* end confdefs.h. */ 5687+#include <math.h> 5688+int 5689+main () 5690+{ 5691+ _powl(0, 0); 5692+ ; 5693+ return 0; 5694+} 5695+_ACEOF 5696+if ac_fn_cxx_try_compile "$LINENO"; then : 5697+ glibcxx_cv_func__powl_use=yes 5698+else 5699+ glibcxx_cv_func__powl_use=no 5700+fi 5701+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5702+ ac_ext=c 5703+ac_cpp='$CPP $CPPFLAGS' 5704+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5705+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5706+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5707+ 5708+ 5709+fi 5710+ 5711+ fi 5712+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__powl_use" >&5 5713+$as_echo "$glibcxx_cv_func__powl_use" >&6; } 5714+ 5715+ if test x$glibcxx_cv_func__powl_use = x"yes"; then 5716+ for ac_func in _powl 5717+do : 5718+ ac_fn_c_check_func "$LINENO" "_powl" "ac_cv_func__powl" 5719+if test "x$ac_cv_func__powl" = x""yes; then : 5720+ cat >>confdefs.h <<_ACEOF 5721+#define HAVE__POWL 1 5722+_ACEOF 5723+ 5724+fi 5725+done 5726+ 5727+ fi 5728+ fi 5729+ 5730+ 5731+ 5732+ 5733+ 5734+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sqrtl declaration" >&5 5735+$as_echo_n "checking for sqrtl declaration... " >&6; } 5736+ if test x${glibcxx_cv_func_sqrtl_use+set} != xset; then 5737+ if test "${glibcxx_cv_func_sqrtl_use+set}" = set; then : 5738+ $as_echo_n "(cached) " >&6 5739+else 5740+ 5741+ 5742+ ac_ext=cpp 5743+ac_cpp='$CXXCPP $CPPFLAGS' 5744+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5745+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5746+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5747+ 5748+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5749+/* end confdefs.h. */ 5750+#include <math.h> 5751+ #ifdef HAVE_IEEEFP_H 5752+ #include <ieeefp.h> 5753+ #endif 5754+ 5755+int 5756+main () 5757+{ 5758+ sqrtl(0); 5759+ ; 5760+ return 0; 5761+} 5762+_ACEOF 5763+if ac_fn_cxx_try_compile "$LINENO"; then : 5764+ glibcxx_cv_func_sqrtl_use=yes 5765+else 5766+ glibcxx_cv_func_sqrtl_use=no 5767+fi 5768+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5769+ ac_ext=c 5770+ac_cpp='$CPP $CPPFLAGS' 5771+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5772+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5773+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5774+ 5775+ 5776+fi 5777+ 5778+ fi 5779+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_sqrtl_use" >&5 5780+$as_echo "$glibcxx_cv_func_sqrtl_use" >&6; } 5781+ 5782+ if test x$glibcxx_cv_func_sqrtl_use = x"yes"; then 5783+ for ac_func in sqrtl 5784+do : 5785+ ac_fn_c_check_func "$LINENO" "sqrtl" "ac_cv_func_sqrtl" 5786+if test "x$ac_cv_func_sqrtl" = x""yes; then : 5787+ cat >>confdefs.h <<_ACEOF 5788+#define HAVE_SQRTL 1 5789+_ACEOF 5790+ 5791+fi 5792+done 5793+ 5794+ else 5795+ 5796+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _sqrtl declaration" >&5 5797+$as_echo_n "checking for _sqrtl declaration... " >&6; } 5798+ if test x${glibcxx_cv_func__sqrtl_use+set} != xset; then 5799+ if test "${glibcxx_cv_func__sqrtl_use+set}" = set; then : 5800+ $as_echo_n "(cached) " >&6 5801+else 5802+ 5803+ 5804+ ac_ext=cpp 5805+ac_cpp='$CXXCPP $CPPFLAGS' 5806+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5807+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5808+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5809+ 5810+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5811+/* end confdefs.h. */ 5812+#include <math.h> 5813+ #ifdef HAVE_IEEEFP_H 5814+ #include <ieeefp.h> 5815+ #endif 5816+ 5817+int 5818+main () 5819+{ 5820+ _sqrtl(0); 5821+ ; 5822+ return 0; 5823+} 5824+_ACEOF 5825+if ac_fn_cxx_try_compile "$LINENO"; then : 5826+ glibcxx_cv_func__sqrtl_use=yes 5827+else 5828+ glibcxx_cv_func__sqrtl_use=no 5829+fi 5830+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5831+ ac_ext=c 5832+ac_cpp='$CPP $CPPFLAGS' 5833+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5834+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5835+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5836+ 5837+ 5838+fi 5839+ 5840+ fi 5841+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__sqrtl_use" >&5 5842+$as_echo "$glibcxx_cv_func__sqrtl_use" >&6; } 5843+ 5844+ if test x$glibcxx_cv_func__sqrtl_use = x"yes"; then 5845+ for ac_func in _sqrtl 5846+do : 5847+ ac_fn_c_check_func "$LINENO" "_sqrtl" "ac_cv_func__sqrtl" 5848+if test "x$ac_cv_func__sqrtl" = x""yes; then : 5849+ cat >>confdefs.h <<_ACEOF 5850+#define HAVE__SQRTL 1 5851+_ACEOF 5852+ 5853+fi 5854+done 5855+ 5856+ fi 5857+ fi 5858+ 5859+ 5860+ 5861+ 5862+ 5863+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sincosl declaration" >&5 5864+$as_echo_n "checking for sincosl declaration... " >&6; } 5865+ if test x${glibcxx_cv_func_sincosl_use+set} != xset; then 5866+ if test "${glibcxx_cv_func_sincosl_use+set}" = set; then : 5867+ $as_echo_n "(cached) " >&6 5868+else 5869+ 5870+ 5871+ ac_ext=cpp 5872+ac_cpp='$CXXCPP $CPPFLAGS' 5873+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5874+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5875+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5876+ 5877+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5878+/* end confdefs.h. */ 5879+#include <math.h> 5880+int 5881+main () 5882+{ 5883+ sincosl(0, 0, 0); 5884+ ; 5885+ return 0; 5886+} 5887+_ACEOF 5888+if ac_fn_cxx_try_compile "$LINENO"; then : 5889+ glibcxx_cv_func_sincosl_use=yes 5890+else 5891+ glibcxx_cv_func_sincosl_use=no 5892+fi 5893+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5894+ ac_ext=c 5895+ac_cpp='$CPP $CPPFLAGS' 5896+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5897+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5898+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5899+ 5900+ 5901+fi 5902+ 5903+ fi 5904+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_sincosl_use" >&5 5905+$as_echo "$glibcxx_cv_func_sincosl_use" >&6; } 5906+ 5907+ if test x$glibcxx_cv_func_sincosl_use = x"yes"; then 5908+ for ac_func in sincosl 5909+do : 5910+ ac_fn_c_check_func "$LINENO" "sincosl" "ac_cv_func_sincosl" 5911+if test "x$ac_cv_func_sincosl" = x""yes; then : 5912+ cat >>confdefs.h <<_ACEOF 5913+#define HAVE_SINCOSL 1 5914+_ACEOF 5915+ 5916+fi 5917+done 5918+ 5919+ else 5920+ 5921+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _sincosl declaration" >&5 5922+$as_echo_n "checking for _sincosl declaration... " >&6; } 5923+ if test x${glibcxx_cv_func__sincosl_use+set} != xset; then 5924+ if test "${glibcxx_cv_func__sincosl_use+set}" = set; then : 5925+ $as_echo_n "(cached) " >&6 5926+else 5927+ 5928+ 5929+ ac_ext=cpp 5930+ac_cpp='$CXXCPP $CPPFLAGS' 5931+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5932+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5933+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5934+ 5935+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5936+/* end confdefs.h. */ 5937+#include <math.h> 5938+int 5939+main () 5940+{ 5941+ _sincosl(0, 0, 0); 5942+ ; 5943+ return 0; 5944+} 5945+_ACEOF 5946+if ac_fn_cxx_try_compile "$LINENO"; then : 5947+ glibcxx_cv_func__sincosl_use=yes 5948+else 5949+ glibcxx_cv_func__sincosl_use=no 5950+fi 5951+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 5952+ ac_ext=c 5953+ac_cpp='$CPP $CPPFLAGS' 5954+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5955+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5956+ac_compiler_gnu=$ac_cv_c_compiler_gnu 5957+ 5958+ 5959+fi 5960+ 5961+ fi 5962+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__sincosl_use" >&5 5963+$as_echo "$glibcxx_cv_func__sincosl_use" >&6; } 5964+ 5965+ if test x$glibcxx_cv_func__sincosl_use = x"yes"; then 5966+ for ac_func in _sincosl 5967+do : 5968+ ac_fn_c_check_func "$LINENO" "_sincosl" "ac_cv_func__sincosl" 5969+if test "x$ac_cv_func__sincosl" = x""yes; then : 5970+ cat >>confdefs.h <<_ACEOF 5971+#define HAVE__SINCOSL 1 5972+_ACEOF 5973+ 5974+fi 5975+done 5976+ 5977+ fi 5978+ fi 5979+ 5980+ 5981+ 5982+ 5983+ 5984+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for finitel declaration" >&5 5985+$as_echo_n "checking for finitel declaration... " >&6; } 5986+ if test x${glibcxx_cv_func_finitel_use+set} != xset; then 5987+ if test "${glibcxx_cv_func_finitel_use+set}" = set; then : 5988+ $as_echo_n "(cached) " >&6 5989+else 5990+ 5991+ 5992+ ac_ext=cpp 5993+ac_cpp='$CXXCPP $CPPFLAGS' 5994+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 5995+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 5996+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 5997+ 5998+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 5999+/* end confdefs.h. */ 6000+#include <math.h> 6001+ #ifdef HAVE_IEEEFP_H 6002+ #include <ieeefp.h> 6003+ #endif 6004+ 6005+int 6006+main () 6007+{ 6008+ finitel(0); 6009+ ; 6010+ return 0; 6011+} 6012+_ACEOF 6013+if ac_fn_cxx_try_compile "$LINENO"; then : 6014+ glibcxx_cv_func_finitel_use=yes 6015+else 6016+ glibcxx_cv_func_finitel_use=no 6017+fi 6018+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6019+ ac_ext=c 6020+ac_cpp='$CPP $CPPFLAGS' 6021+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6022+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6023+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6024+ 6025+ 6026+fi 6027+ 6028+ fi 6029+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_finitel_use" >&5 6030+$as_echo "$glibcxx_cv_func_finitel_use" >&6; } 6031+ 6032+ if test x$glibcxx_cv_func_finitel_use = x"yes"; then 6033+ for ac_func in finitel 6034+do : 6035+ ac_fn_c_check_func "$LINENO" "finitel" "ac_cv_func_finitel" 6036+if test "x$ac_cv_func_finitel" = x""yes; then : 6037+ cat >>confdefs.h <<_ACEOF 6038+#define HAVE_FINITEL 1 6039+_ACEOF 6040+ 6041+fi 6042+done 6043+ 6044+ else 6045+ 6046+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _finitel declaration" >&5 6047+$as_echo_n "checking for _finitel declaration... " >&6; } 6048+ if test x${glibcxx_cv_func__finitel_use+set} != xset; then 6049+ if test "${glibcxx_cv_func__finitel_use+set}" = set; then : 6050+ $as_echo_n "(cached) " >&6 6051+else 6052+ 6053+ 6054+ ac_ext=cpp 6055+ac_cpp='$CXXCPP $CPPFLAGS' 6056+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6057+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6058+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 6059+ 6060+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6061+/* end confdefs.h. */ 6062+#include <math.h> 6063+ #ifdef HAVE_IEEEFP_H 6064+ #include <ieeefp.h> 6065+ #endif 6066+ 6067+int 6068+main () 6069+{ 6070+ _finitel(0); 6071+ ; 6072+ return 0; 6073+} 6074+_ACEOF 6075+if ac_fn_cxx_try_compile "$LINENO"; then : 6076+ glibcxx_cv_func__finitel_use=yes 6077+else 6078+ glibcxx_cv_func__finitel_use=no 6079+fi 6080+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6081+ ac_ext=c 6082+ac_cpp='$CPP $CPPFLAGS' 6083+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6084+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6085+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6086+ 6087+ 6088+fi 6089+ 6090+ fi 6091+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func__finitel_use" >&5 6092+$as_echo "$glibcxx_cv_func__finitel_use" >&6; } 6093+ 6094+ if test x$glibcxx_cv_func__finitel_use = x"yes"; then 6095+ for ac_func in _finitel 6096+do : 6097+ ac_fn_c_check_func "$LINENO" "_finitel" "ac_cv_func__finitel" 6098+if test "x$ac_cv_func__finitel" = x""yes; then : 6099+ cat >>confdefs.h <<_ACEOF 6100+#define HAVE__FINITEL 1 6101+_ACEOF 6102+ 6103+fi 6104+done 6105+ 6106+ fi 6107+ fi 6108+ 6109+ 6110+ 6111+ 6112+ LIBS="$ac_save_LIBS" 6113+ CXXFLAGS="$ac_save_CXXFLAGS" 6114+ 6115+ 6116+ ac_test_CXXFLAGS="${CXXFLAGS+set}" 6117+ ac_save_CXXFLAGS="$CXXFLAGS" 6118+ CXXFLAGS='-fno-builtin -D_GNU_SOURCE' 6119+ 6120+ 6121+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for at_quick_exit declaration" >&5 6122+$as_echo_n "checking for at_quick_exit declaration... " >&6; } 6123+ if test x${glibcxx_cv_func_at_quick_exit_use+set} != xset; then 6124+ if test "${glibcxx_cv_func_at_quick_exit_use+set}" = set; then : 6125+ $as_echo_n "(cached) " >&6 6126+else 6127+ 6128+ 6129+ ac_ext=cpp 6130+ac_cpp='$CXXCPP $CPPFLAGS' 6131+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6132+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6133+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 6134+ 6135+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6136+/* end confdefs.h. */ 6137+#include <stdlib.h> 6138+int 6139+main () 6140+{ 6141+ at_quick_exit(0); 6142+ ; 6143+ return 0; 6144+} 6145+_ACEOF 6146+if ac_fn_cxx_try_compile "$LINENO"; then : 6147+ glibcxx_cv_func_at_quick_exit_use=yes 6148+else 6149+ glibcxx_cv_func_at_quick_exit_use=no 6150+fi 6151+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6152+ ac_ext=c 6153+ac_cpp='$CPP $CPPFLAGS' 6154+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6155+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6156+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6157+ 6158+ 6159+fi 6160+ 6161+ fi 6162+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_at_quick_exit_use" >&5 6163+$as_echo "$glibcxx_cv_func_at_quick_exit_use" >&6; } 6164+ if test x$glibcxx_cv_func_at_quick_exit_use = x"yes"; then 6165+ for ac_func in at_quick_exit 6166+do : 6167+ ac_fn_c_check_func "$LINENO" "at_quick_exit" "ac_cv_func_at_quick_exit" 6168+if test "x$ac_cv_func_at_quick_exit" = x""yes; then : 6169+ cat >>confdefs.h <<_ACEOF 6170+#define HAVE_AT_QUICK_EXIT 1 6171+_ACEOF 6172+ 6173+fi 6174+done 6175+ 6176+ fi 6177+ 6178+ 6179+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for quick_exit declaration" >&5 6180+$as_echo_n "checking for quick_exit declaration... " >&6; } 6181+ if test x${glibcxx_cv_func_quick_exit_use+set} != xset; then 6182+ if test "${glibcxx_cv_func_quick_exit_use+set}" = set; then : 6183+ $as_echo_n "(cached) " >&6 6184+else 6185+ 6186+ 6187+ ac_ext=cpp 6188+ac_cpp='$CXXCPP $CPPFLAGS' 6189+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6190+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6191+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 6192+ 6193+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6194+/* end confdefs.h. */ 6195+#include <stdlib.h> 6196+int 6197+main () 6198+{ 6199+ quick_exit(0); 6200+ ; 6201+ return 0; 6202+} 6203+_ACEOF 6204+if ac_fn_cxx_try_compile "$LINENO"; then : 6205+ glibcxx_cv_func_quick_exit_use=yes 6206+else 6207+ glibcxx_cv_func_quick_exit_use=no 6208+fi 6209+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6210+ ac_ext=c 6211+ac_cpp='$CPP $CPPFLAGS' 6212+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6213+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6214+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6215+ 6216+ 6217+fi 6218+ 6219+ fi 6220+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_quick_exit_use" >&5 6221+$as_echo "$glibcxx_cv_func_quick_exit_use" >&6; } 6222+ if test x$glibcxx_cv_func_quick_exit_use = x"yes"; then 6223+ for ac_func in quick_exit 6224+do : 6225+ ac_fn_c_check_func "$LINENO" "quick_exit" "ac_cv_func_quick_exit" 6226+if test "x$ac_cv_func_quick_exit" = x""yes; then : 6227+ cat >>confdefs.h <<_ACEOF 6228+#define HAVE_QUICK_EXIT 1 6229+_ACEOF 6230+ 6231+fi 6232+done 6233+ 6234+ fi 6235+ 6236+ 6237+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strtold declaration" >&5 6238+$as_echo_n "checking for strtold declaration... " >&6; } 6239+ if test x${glibcxx_cv_func_strtold_use+set} != xset; then 6240+ if test "${glibcxx_cv_func_strtold_use+set}" = set; then : 6241+ $as_echo_n "(cached) " >&6 6242+else 6243+ 6244+ 6245+ ac_ext=cpp 6246+ac_cpp='$CXXCPP $CPPFLAGS' 6247+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6248+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6249+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 6250+ 6251+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6252+/* end confdefs.h. */ 6253+#include <stdlib.h> 6254+int 6255+main () 6256+{ 6257+ strtold(0, 0); 6258+ ; 6259+ return 0; 6260+} 6261+_ACEOF 6262+if ac_fn_cxx_try_compile "$LINENO"; then : 6263+ glibcxx_cv_func_strtold_use=yes 6264+else 6265+ glibcxx_cv_func_strtold_use=no 6266+fi 6267+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6268+ ac_ext=c 6269+ac_cpp='$CPP $CPPFLAGS' 6270+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6271+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6272+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6273+ 6274+ 6275+fi 6276+ 6277+ fi 6278+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_strtold_use" >&5 6279+$as_echo "$glibcxx_cv_func_strtold_use" >&6; } 6280+ if test x$glibcxx_cv_func_strtold_use = x"yes"; then 6281+ for ac_func in strtold 6282+do : 6283+ ac_fn_c_check_func "$LINENO" "strtold" "ac_cv_func_strtold" 6284+if test "x$ac_cv_func_strtold" = x""yes; then : 6285+ cat >>confdefs.h <<_ACEOF 6286+#define HAVE_STRTOLD 1 6287+_ACEOF 6288+ 6289+fi 6290+done 6291+ 6292+ fi 6293+ 6294+ 6295+ 6296+ 6297+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strtof declaration" >&5 6298+$as_echo_n "checking for strtof declaration... " >&6; } 6299+ if test x${glibcxx_cv_func_strtof_use+set} != xset; then 6300+ if test "${glibcxx_cv_func_strtof_use+set}" = set; then : 6301+ $as_echo_n "(cached) " >&6 6302+else 6303+ 6304+ 6305+ ac_ext=cpp 6306+ac_cpp='$CXXCPP $CPPFLAGS' 6307+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6308+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6309+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu 6310+ 6311+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext 6312+/* end confdefs.h. */ 6313+#include <stdlib.h> 6314+int 6315+main () 6316+{ 6317+ strtof(0, 0); 6318+ ; 6319+ return 0; 6320+} 6321+_ACEOF 6322+if ac_fn_cxx_try_compile "$LINENO"; then : 6323+ glibcxx_cv_func_strtof_use=yes 6324+else 6325+ glibcxx_cv_func_strtof_use=no 6326+fi 6327+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext 6328+ ac_ext=c 6329+ac_cpp='$CPP $CPPFLAGS' 6330+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' 6331+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' 6332+ac_compiler_gnu=$ac_cv_c_compiler_gnu 6333+ 6334+ 6335+fi 6336+ 6337+ fi 6338+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_func_strtof_use" >&5 6339+$as_echo "$glibcxx_cv_func_strtof_use" >&6; } 6340+ if test x$glibcxx_cv_func_strtof_use = x"yes"; then 6341+ for ac_func in strtof 6342+do : 6343+ ac_fn_c_check_func "$LINENO" "strtof" "ac_cv_func_strtof" 6344+if test "x$ac_cv_func_strtof" = x""yes; then : 6345+ cat >>confdefs.h <<_ACEOF 6346+#define HAVE_STRTOF 1 6347+_ACEOF 6348+ 6349+fi 6350+done 6351+ 6352+ fi 6353+ 6354+ 6355+ 6356+ 6357+ CXXFLAGS="$ac_save_CXXFLAGS" 6358+ 6359+ ;; 6360 *-mingw32*) 6361 6362 # If we're not using GNU ld, then there's no point in even trying these 6363diff --git a/libstdc++-v3/crossconfig.m4 b/libstdc++-v3/crossconfig.m4 6364index 943ea676ea27..3e4e92454568 100644 6365--- a/libstdc++-v3/crossconfig.m4 6366+++ b/libstdc++-v3/crossconfig.m4 6367@@ -150,6 +150,12 @@ case "${host}" in 6368 GCC_CHECK_TLS 6369 AM_ICONV 6370 ;; 6371+ *-barrelfish*) 6372+ GLIBCXX_CHECK_COMPILER_FEATURES 6373+ GLIBCXX_CHECK_LINKER_FEATURES 6374+ GLIBCXX_CHECK_MATH_SUPPORT 6375+ GLIBCXX_CHECK_STDLIB_SUPPORT 6376+ ;; 6377 *-mingw32*) 6378 GLIBCXX_CHECK_LINKER_FEATURES 6379 GLIBCXX_CHECK_MATH_SUPPORT 6380diff --git a/libstdc++-v3/include/c_global/csignal b/libstdc++-v3/include/c_global/csignal 6381index 16446f502829..aa0f0067b044 100644 6382--- a/libstdc++-v3/include/c_global/csignal 6383+++ b/libstdc++-v3/include/c_global/csignal 6384@@ -49,9 +49,9 @@ 6385 6386 namespace std 6387 { 6388- using ::sig_atomic_t; 6389+ //using ::sig_atomic_t; 6390 using ::signal; 6391- using ::raise; 6392+ //using ::raise; 6393 } // namespace std 6394 6395 #endif 6396