OSDN Git Service

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