OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [acinclude.m4] - Blame information for rev 747

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn
dnl
2
dnl GLIBCXX_CONDITIONAL (NAME, SHELL-TEST)
3
dnl
4
dnl Exactly like AM_CONDITIONAL, but delays evaluation of the test until the
5
dnl end of configure.  This lets tested variables be reassigned, and the
6
dnl conditional will depend on the final state of the variable.  For a simple
7
dnl example of why this is needed, see GLIBCXX_ENABLE_HOSTED.
8
dnl
9
m4_define([_m4_divert(glibcxx_diversion)], 8000)dnl
10
AC_DEFUN([GLIBCXX_CONDITIONAL], [dnl
11
  m4_divert_text([glibcxx_diversion],dnl
12
   AM_CONDITIONAL([$1],[$2])
13
  )dnl
14
])dnl
15
AC_DEFUN([GLIBCXX_EVALUATE_CONDITIONALS], [m4_undivert([glibcxx_diversion])])dnl
16
 
17
 
18
dnl
19
dnl Check to see what architecture and operating system we are compiling
20
dnl for.  Also, if architecture- or OS-specific flags are required for
21
dnl compilation, pick them up here.
22
dnl
23
AC_DEFUN([GLIBCXX_CHECK_HOST], [
24
  . $glibcxx_srcdir/configure.host
25
  AC_MSG_NOTICE([CPU config directory is $cpu_include_dir])
26
  AC_MSG_NOTICE([OS config directory is $os_include_dir])
27
])
28
 
29
dnl
30
dnl Initialize the rest of the library configury.  At this point we have
31
dnl variables like $host.
32
dnl
33
dnl Sets:
34
dnl  SUBDIRS
35
dnl Substs:
36
dnl  glibcxx_builddir     (absolute path)
37
dnl  glibcxx_srcdir       (absolute path)
38
dnl  toplevel_builddir    (absolute path)
39
dnl  toplevel_srcdir      (absolute path)
40
dnl  with_cross_host
41
dnl  with_newlib
42
dnl  with_target_subdir
43
dnl plus
44
dnl  - the variables in GLIBCXX_CHECK_HOST / configure.host
45
dnl  - default settings for all AM_CONFITIONAL test variables
46
dnl  - lots of tools, like CC and CXX
47
dnl
48
AC_DEFUN([GLIBCXX_CONFIGURE], [
49
  # Keep these sync'd with the list in Makefile.am.  The first provides an
50
  # expandable list at autoconf time; the second provides an expandable list
51
  # (i.e., shell variable) at configure time.
52
  m4_define([glibcxx_SUBDIRS],[include libsupc++ python src src/c++98 src/c++11 doc po testsuite])
53
  SUBDIRS='glibcxx_SUBDIRS'
54
 
55
  # These need to be absolute paths, yet at the same time need to
56
  # canonicalize only relative paths, because then amd will not unmount
57
  # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
58
  glibcxx_builddir=`${PWDCMD-pwd}`
59
  case $srcdir in
60
    [\\/$]* | ?:[\\/]*) glibcxx_srcdir=${srcdir} ;;
61
    *) glibcxx_srcdir=`cd "$srcdir" && ${PWDCMD-pwd} || echo "$srcdir"` ;;
62
  esac
63
  toplevel_builddir=${glibcxx_builddir}/..
64
  toplevel_srcdir=${glibcxx_srcdir}/..
65
  AC_SUBST(glibcxx_builddir)
66
  AC_SUBST(glibcxx_srcdir)
67
  AC_SUBST(toplevel_builddir)
68
  AC_SUBST(toplevel_srcdir)
69
 
70
  # We use these options to decide which functions to include.  They are
71
  # set from the top level.
72
  AC_ARG_WITH([target-subdir],
73
    AC_HELP_STRING([--with-target-subdir=SUBDIR],
74
                   [configuring in a subdirectory]))
75
 
76
  AC_ARG_WITH([cross-host],
77
    AC_HELP_STRING([--with-cross-host=HOST],
78
                   [configuring with a cross compiler]))
79
 
80
  AC_ARG_WITH([newlib],
81
    AC_HELP_STRING([--with-newlib],
82
                   [assume newlib as a system C library]))
83
 
84
  # Will set LN_S to either 'ln -s', 'ln', or 'cp -p' (if linking isn't
85
  # available).  Uncomment the next line to force a particular method.
86
  AC_PROG_LN_S
87
  #LN_S='cp -p'
88
 
89
  AC_CHECK_TOOL(AS, as)
90
  AC_CHECK_TOOL(AR, ar)
91
  AC_CHECK_TOOL(RANLIB, ranlib, ranlib-not-found-in-path-error)
92
 
93
  AM_MAINTAINER_MODE
94
 
95
  # Set up safe default values for all subsequent AM_CONDITIONAL tests
96
  # which are themselves conditionally expanded.
97
  ## (Right now, this only matters for enable_wchar_t, but nothing prevents
98
  ## other macros from doing the same.  This should be automated.)  -pme
99
 
100
  # Check for C library flavor since GNU/Linux platforms use different
101
  # configuration directories depending on the C library in use.
102
  AC_EGREP_CPP([_using_uclibc], [
103
  #include <stdio.h>
104
  #if __UCLIBC__
105
    _using_uclibc
106
  #endif
107
  ], uclibc=yes, uclibc=no)
108
 
109
  AC_EGREP_CPP([_using_bionic], [
110
  #include <stdio.h>
111
  #if __BIONIC__
112
    _using_bionic
113
  #endif
114
  ], bionic=yes, bionic=no)
115
 
116
  # Find platform-specific directories containing configuration info.
117
  # Also possibly modify flags used elsewhere, as needed by the platform.
118
  GLIBCXX_CHECK_HOST
119
])
120
 
121
 
122
dnl
123
dnl Tests for newer compiler features, or features that are present in newer
124
dnl compiler versions but not older compiler versions still in use, should
125
dnl be placed here.
126
dnl
127
dnl Defines:
128
dnl  WERROR='-Werror' if requested and possible; g++'s that lack the
129
dnl   new inlining code or the new system_header pragma will die on -Werror.
130
dnl   Leave it out by default and use maint-mode to use it.
131
dnl  SECTION_FLAGS='-ffunction-sections -fdata-sections' if
132
dnl   compiler supports it and the user has not requested debug mode.
133
dnl
134
AC_DEFUN([GLIBCXX_CHECK_COMPILER_FEATURES], [
135
  # All these tests are for C++; save the language and the compiler flags.
136
  # The CXXFLAGS thing is suspicious, but based on similar bits previously
137
  # found in GLIBCXX_CONFIGURE.
138
  AC_LANG_SAVE
139
  AC_LANG_CPLUSPLUS
140
  ac_test_CXXFLAGS="${CXXFLAGS+set}"
141
  ac_save_CXXFLAGS="$CXXFLAGS"
142
 
143
  # Check for maintainer-mode bits.
144
  if test x"$USE_MAINTAINER_MODE" = xno; then
145
    WERROR=''
146
  else
147
    WERROR='-Werror'
148
  fi
149
 
150
  # Check for -ffunction-sections -fdata-sections
151
  AC_MSG_CHECKING([for g++ that supports -ffunction-sections -fdata-sections])
152
  CXXFLAGS='-g -Werror -ffunction-sections -fdata-sections'
153
  AC_TRY_COMPILE([int foo; void bar() { };],, [ac_fdsections=yes], [ac_fdsections=no])
154
  if test "$ac_test_CXXFLAGS" = set; then
155
    CXXFLAGS="$ac_save_CXXFLAGS"
156
  else
157
    # this is the suspicious part
158
    CXXFLAGS=''
159
  fi
160
  if test x"$ac_fdsections" = x"yes"; then
161
    SECTION_FLAGS='-ffunction-sections -fdata-sections'
162
  fi
163
  AC_MSG_RESULT($ac_fdsections)
164
 
165
  AC_LANG_RESTORE
166
  AC_SUBST(WERROR)
167
  AC_SUBST(SECTION_FLAGS)
168
])
169
 
170
 
171
dnl
172
dnl If GNU ld is in use, check to see if tricky linker opts can be used.  If
173
dnl the native linker is in use, all variables will be defined to something
174
dnl safe (like an empty string).
175
dnl
176
dnl Defines:
177
dnl  SECTION_LDFLAGS='-Wl,--gc-sections' if possible
178
dnl  OPT_LDFLAGS='-Wl,-O1' and '-z,relro' if possible
179
dnl  LD (as a side effect of testing)
180
dnl Sets:
181
dnl  with_gnu_ld
182
dnl  glibcxx_ld_is_gold (set to "no" or "yes")
183
dnl  glibcxx_gnu_ld_version (possibly)
184
dnl
185
dnl The last will be a single integer, e.g., version 1.23.45.0.67.89 will
186
dnl set glibcxx_gnu_ld_version to 12345.  Zeros cause problems.
187
dnl
188
AC_DEFUN([GLIBCXX_CHECK_LINKER_FEATURES], [
189
  # If we're not using GNU ld, then there's no point in even trying these
190
  # tests.  Check for that first.  We should have already tested for gld
191
  # by now (in libtool), but require it now just to be safe...
192
  test -z "$SECTION_LDFLAGS" && SECTION_LDFLAGS=''
193
  test -z "$OPT_LDFLAGS" && OPT_LDFLAGS=''
194
  AC_REQUIRE([AC_PROG_LD])
195
  AC_REQUIRE([AC_PROG_AWK])
196
 
197
  # The name set by libtool depends on the version of libtool.  Shame on us
198
  # for depending on an impl detail, but c'est la vie.  Older versions used
199
  # ac_cv_prog_gnu_ld, but now it's lt_cv_prog_gnu_ld, and is copied back on
200
  # top of with_gnu_ld (which is also set by --with-gnu-ld, so that actually
201
  # makes sense).  We'll test with_gnu_ld everywhere else, so if that isn't
202
  # set (hence we're using an older libtool), then set it.
203
  if test x${with_gnu_ld+set} != xset; then
204
    if test x${ac_cv_prog_gnu_ld+set} != xset; then
205
      # We got through "ac_require(ac_prog_ld)" and still not set?  Huh?
206
      with_gnu_ld=no
207
    else
208
      with_gnu_ld=$ac_cv_prog_gnu_ld
209
    fi
210
  fi
211
 
212
  # Start by getting the version number.  I think the libtool test already
213
  # does some of this, but throws away the result.
214
  glibcxx_ld_is_gold=no
215
  if test x"$with_gnu_ld" = x"yes"; then
216
    AC_MSG_CHECKING([for ld version])
217
    changequote(,)
218
    if $LD --version 2>/dev/null | grep 'GNU gold' >/dev/null 2>&1; then
219
      glibcxx_ld_is_gold=yes
220
    fi
221
    ldver=`$LD --version 2>/dev/null |
222
           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'`
223
    changequote([,])
224
    glibcxx_gnu_ld_version=`echo $ldver | \
225
           $AWK -F. '{ if (NF<3) [$]3=0; print ([$]1*100+[$]2)*100+[$]3 }'`
226
    AC_MSG_RESULT($glibcxx_gnu_ld_version)
227
  fi
228
 
229
  # Set --gc-sections.
230
  glibcxx_have_gc_sections=no
231
  if test "$glibcxx_ld_is_gold" = "yes"; then
232
    if $LD --help 2>/dev/null | grep gc-sections >/dev/null 2>&1; then
233
      glibcxx_have_gc_sections=yes
234
    fi
235
  else
236
    glibcxx_gcsections_min_ld=21602
237
    if test x"$with_gnu_ld" = x"yes" &&
238
        test $glibcxx_gnu_ld_version -gt $glibcxx_gcsections_min_ld ; then
239
      glibcxx_have_gc_sections=yes
240
    fi
241
  fi
242
  if test "$glibcxx_have_gc_sections" = "yes"; then
243
    # Sufficiently young GNU ld it is!  Joy and bunny rabbits!
244
    # NB: This flag only works reliably after 2.16.1. Configure tests
245
    # for this are difficult, so hard wire a value that should work.
246
 
247
    ac_test_CFLAGS="${CFLAGS+set}"
248
    ac_save_CFLAGS="$CFLAGS"
249
    CFLAGS='-Wl,--gc-sections'
250
 
251
    # Check for -Wl,--gc-sections
252
    AC_MSG_CHECKING([for ld that supports -Wl,--gc-sections])
253
    AC_TRY_LINK([ int one(void) { return 1; }
254
     int two(void) { return 2; }
255
        ], [ two(); ] , [ac_gcsections=yes], [ac_gcsections=no])
256
    if test "$ac_gcsections" = "yes"; then
257
      rm -f conftest.c
258
      touch conftest.c
259
      if $CC -c conftest.c; then
260
        if $LD --gc-sections -o conftest conftest.o 2>&1 | \
261
           grep "Warning: gc-sections option ignored" > /dev/null; then
262
          ac_gcsections=no
263
        fi
264
      fi
265
      rm -f conftest.c conftest.o conftest
266
    fi
267
    if test "$ac_gcsections" = "yes"; then
268
      SECTION_LDFLAGS="-Wl,--gc-sections $SECTION_LDFLAGS"
269
    fi
270
    AC_MSG_RESULT($ac_gcsections)
271
 
272
    if test "$ac_test_CFLAGS" = set; then
273
      CFLAGS="$ac_save_CFLAGS"
274
    else
275
      # this is the suspicious part
276
      CFLAGS=''
277
    fi
278
  fi
279
 
280
  # Set -z,relro.
281
  # Note this is only for shared objects.
282
  ac_ld_relro=no
283
  if test x"$with_gnu_ld" = x"yes"; then
284
    AC_MSG_CHECKING([for ld that supports -Wl,-z,relro])
285
    cxx_z_relo=`$LD -v --help 2>/dev/null | grep "z relro"`
286
    if test -n "$cxx_z_relo"; then
287
      OPT_LDFLAGS="-Wl,-z,relro"
288
      ac_ld_relro=yes
289
    fi
290
    AC_MSG_RESULT($ac_ld_relro)
291
  fi
292
 
293
  # Set linker optimization flags.
294
  if test x"$with_gnu_ld" = x"yes"; then
295
    OPT_LDFLAGS="-Wl,-O1 $OPT_LDFLAGS"
296
  fi
297
 
298
  AC_SUBST(SECTION_LDFLAGS)
299
  AC_SUBST(OPT_LDFLAGS)
300
])
301
 
302
 
303
dnl
304
dnl Check for headers for, and arguments to, the setrlimit() function.
305
dnl Used only in testsuite_hooks.h.  Called from GLIBCXX_CONFIGURE_TESTSUITE.
306
dnl
307
dnl Defines:
308
dnl  _GLIBCXX_RES_LIMITS if we can set artificial resource limits
309
dnl  various HAVE_LIMIT_* for individual limit names
310
dnl
311
AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT_ancilliary], [
312
  AC_MSG_CHECKING([for RLIMIT_$1])
313
  AC_TRY_COMPILE(
314
    [#include <unistd.h>
315
     #include <sys/time.h>
316
     #include <sys/resource.h>
317
    ],
318
    [ int f = RLIMIT_$1 ; ],
319
    [glibcxx_mresult=1], [glibcxx_mresult=0])
320
  AC_DEFINE_UNQUOTED(HAVE_LIMIT_$1, $glibcxx_mresult,
321
                     [Only used in build directory testsuite_hooks.h.])
322
  if test $glibcxx_mresult = 1 ; then res=yes ; else res=no ; fi
323
  AC_MSG_RESULT($res)
324
])
325
 
326
AC_DEFUN([GLIBCXX_CHECK_SETRLIMIT], [
327
  setrlimit_have_headers=yes
328
  AC_CHECK_HEADERS(unistd.h sys/time.h sys/resource.h,
329
                   [],
330
                   [setrlimit_have_headers=no])
331
  # If don't have the headers, then we can't run the tests now, and we
332
  # won't be seeing any of these during testsuite compilation.
333
  if test $setrlimit_have_headers = yes; then
334
    # Can't do these in a loop, else the resulting syntax is wrong.
335
    GLIBCXX_CHECK_SETRLIMIT_ancilliary(DATA)
336
    GLIBCXX_CHECK_SETRLIMIT_ancilliary(RSS)
337
    GLIBCXX_CHECK_SETRLIMIT_ancilliary(VMEM)
338
    GLIBCXX_CHECK_SETRLIMIT_ancilliary(AS)
339
    GLIBCXX_CHECK_SETRLIMIT_ancilliary(FSIZE)
340
 
341
    # Check for rlimit, setrlimit.
342
    AC_CACHE_VAL(glibcxx_cv_setrlimit, [
343
      AC_TRY_COMPILE(
344
        [#include <unistd.h>
345
         #include <sys/time.h>
346
         #include <sys/resource.h>
347
        ],
348
        [struct rlimit r;
349
         setrlimit(0, &r);],
350
        [glibcxx_cv_setrlimit=yes], [glibcxx_cv_setrlimit=no])
351
    ])
352
  fi
353
 
354
  AC_MSG_CHECKING([for testsuite resource limits support])
355
  if test $setrlimit_have_headers = yes && test $glibcxx_cv_setrlimit = yes; then
356
    ac_res_limits=yes
357
    AC_DEFINE(_GLIBCXX_RES_LIMITS, 1,
358
              [Define if using setrlimit to set resource limits during
359
              "make check"])
360
  else
361
    ac_res_limits=no
362
  fi
363
  AC_MSG_RESULT($ac_res_limits)
364
])
365
 
366
 
367
dnl
368
dnl Check whether S_ISREG (Posix) or S_IFREG is available in <sys/stat.h>.
369
dnl Define HAVE_S_ISREG / HAVE_S_IFREG appropriately.
370
dnl
371
AC_DEFUN([GLIBCXX_CHECK_S_ISREG_OR_S_IFREG], [
372
 
373
  AC_LANG_SAVE
374
  AC_LANG_CPLUSPLUS
375
  ac_save_CXXFLAGS="$CXXFLAGS"
376
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
377
 
378
  AC_MSG_CHECKING([for S_ISREG or S_IFREG])
379
  AC_CACHE_VAL(glibcxx_cv_S_ISREG, [
380
    GCC_TRY_COMPILE_OR_LINK(
381
      [#include <sys/stat.h>],
382
      [struct stat buffer;
383
       fstat(0, &buffer);
384
       S_ISREG(buffer.st_mode);],
385
      [glibcxx_cv_S_ISREG=yes],
386
      [glibcxx_cv_S_ISREG=no])
387
  ])
388
  AC_CACHE_VAL(glibcxx_cv_S_IFREG, [
389
    GCC_TRY_COMPILE_OR_LINK(
390
      [#include <sys/stat.h>],
391
      [struct stat buffer;
392
       fstat(0, &buffer);
393
       S_IFREG & buffer.st_mode;],
394
      [glibcxx_cv_S_IFREG=yes],
395
      [glibcxx_cv_S_IFREG=no])
396
  ])
397
  res=no
398
  if test $glibcxx_cv_S_ISREG = yes; then
399
    AC_DEFINE(HAVE_S_ISREG, 1,
400
              [Define if S_IFREG is available in <sys/stat.h>.])
401
    res=S_ISREG
402
  elif test $glibcxx_cv_S_IFREG = yes; then
403
    AC_DEFINE(HAVE_S_IFREG, 1,
404
              [Define if S_IFREG is available in <sys/stat.h>.])
405
    res=S_IFREG
406
  fi
407
  AC_MSG_RESULT($res)
408
 
409
  CXXFLAGS="$ac_save_CXXFLAGS"
410
  AC_LANG_RESTORE
411
])
412
 
413
 
414
dnl
415
dnl Check whether poll is available in <poll.h>, and define HAVE_POLL.
416
dnl
417
AC_DEFUN([GLIBCXX_CHECK_POLL], [
418
 
419
  AC_LANG_SAVE
420
  AC_LANG_CPLUSPLUS
421
  ac_save_CXXFLAGS="$CXXFLAGS"
422
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
423
 
424
  AC_MSG_CHECKING([for poll])
425
  AC_CACHE_VAL(glibcxx_cv_POLL, [
426
    GCC_TRY_COMPILE_OR_LINK(
427
      [#include <poll.h>],
428
      [struct pollfd pfd[1];
429
       pfd[0].events = POLLIN;
430
       poll(pfd, 1, 0);],
431
      [glibcxx_cv_POLL=yes],
432
      [glibcxx_cv_POLL=no])
433
  ])
434
  if test $glibcxx_cv_POLL = yes; then
435
    AC_DEFINE(HAVE_POLL, 1, [Define if poll is available in <poll.h>.])
436
  fi
437
  AC_MSG_RESULT($glibcxx_cv_POLL)
438
 
439
  CXXFLAGS="$ac_save_CXXFLAGS"
440
  AC_LANG_RESTORE
441
])
442
 
443
 
444
dnl
445
dnl Check whether writev is available in <sys/uio.h>, and define HAVE_WRITEV.
446
dnl
447
AC_DEFUN([GLIBCXX_CHECK_WRITEV], [
448
 
449
  AC_LANG_SAVE
450
  AC_LANG_CPLUSPLUS
451
  ac_save_CXXFLAGS="$CXXFLAGS"
452
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
453
 
454
  AC_MSG_CHECKING([for writev])
455
  AC_CACHE_VAL(glibcxx_cv_WRITEV, [
456
    GCC_TRY_COMPILE_OR_LINK(
457
      [#include <sys/uio.h>],
458
      [struct iovec iov[2];
459
       writev(0, iov, 0);],
460
      [glibcxx_cv_WRITEV=yes],
461
      [glibcxx_cv_WRITEV=no])
462
  ])
463
  if test $glibcxx_cv_WRITEV = yes; then
464
    AC_DEFINE(HAVE_WRITEV, 1, [Define if writev is available in <sys/uio.h>.])
465
  fi
466
  AC_MSG_RESULT($glibcxx_cv_WRITEV)
467
 
468
  CXXFLAGS="$ac_save_CXXFLAGS"
469
  AC_LANG_RESTORE
470
])
471
 
472
 
473
dnl
474
dnl Check whether int64_t is available in <stdint.h>, and define HAVE_INT64_T.
475
dnl Also check whether int64_t is actually a typedef to long or long long.
476
dnl
477
AC_DEFUN([GLIBCXX_CHECK_INT64_T], [
478
 
479
  AC_LANG_SAVE
480
  AC_LANG_CPLUSPLUS
481
 
482
  AC_MSG_CHECKING([for int64_t])
483
  AC_CACHE_VAL(glibcxx_cv_INT64_T, [
484
    AC_TRY_COMPILE(
485
      [#include <stdint.h>],
486
      [int64_t var;],
487
      [glibcxx_cv_INT64_T=yes],
488
      [glibcxx_cv_INT64_T=no])
489
  ])
490
 
491
  if test $glibcxx_cv_INT64_T = yes; then
492
    AC_DEFINE(HAVE_INT64_T, 1, [Define if int64_t is available in <stdint.h>.])
493
    AC_MSG_RESULT($glibcxx_cv_INT64_T)
494
 
495
    AC_MSG_CHECKING([for int64_t as long])
496
    AC_CACHE_VAL(glibcxx_cv_int64_t_long, [
497
      AC_TRY_COMPILE(
498
        [#include <stdint.h>
499
        template<typename, typename> struct same { enum { value = -1 }; };
500
        template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
501
        int array[same<int64_t, long>::value];], [],
502
        [glibcxx_cv_int64_t_long=yes], [glibcxx_cv_int64_t_long=no])
503
    ])
504
 
505
    if test $glibcxx_cv_int64_t_long = yes; then
506
      AC_DEFINE(HAVE_INT64_T_LONG, 1, [Define if int64_t is a long.])
507
      AC_MSG_RESULT($glibcxx_cv_int64_t_long)
508
    fi
509
 
510
    AC_MSG_CHECKING([for int64_t as long long])
511
    AC_CACHE_VAL(glibcxx_cv_int64_t_long_long, [
512
      AC_TRY_COMPILE(
513
        [#include <stdint.h>
514
        template<typename, typename> struct same { enum { value = -1 }; };
515
        template<typename Tp> struct same<Tp, Tp> { enum { value = 1 }; };
516
        int array[same<int64_t, long long>::value];], [],
517
        [glibcxx_cv_int64_t_long_long=yes], [glibcxx_cv_int64_t_long_long=no])
518
    ])
519
 
520
    if test $glibcxx_cv_int64_t_long_long = yes; then
521
      AC_DEFINE(HAVE_INT64_T_LONG_LONG, 1, [Define if int64_t is a long long.])
522
      AC_MSG_RESULT($glibcxx_cv_int64_t_long_long)
523
    fi
524
  fi
525
 
526
  AC_LANG_RESTORE
527
])
528
 
529
 
530
dnl
531
dnl Check whether LFS support is available.
532
dnl
533
AC_DEFUN([GLIBCXX_CHECK_LFS], [
534
  AC_LANG_SAVE
535
  AC_LANG_CPLUSPLUS
536
  ac_save_CXXFLAGS="$CXXFLAGS"
537
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
538
  AC_MSG_CHECKING([for LFS support])
539
  AC_CACHE_VAL(glibcxx_cv_LFS, [
540
    GCC_TRY_COMPILE_OR_LINK(
541
      [#include <unistd.h>
542
       #include <stdio.h>
543
       #include <sys/stat.h>
544
      ],
545
      [FILE* fp;
546
       fopen64("t", "w");
547
       fseeko64(fp, 0, SEEK_CUR);
548
       ftello64(fp);
549
       lseek64(1, 0, SEEK_CUR);
550
       struct stat64 buf;
551
       fstat64(1, &buf);],
552
      [glibcxx_cv_LFS=yes],
553
      [glibcxx_cv_LFS=no])
554
  ])
555
  if test $glibcxx_cv_LFS = yes; then
556
    AC_DEFINE(_GLIBCXX_USE_LFS, 1, [Define if LFS support is available.])
557
  fi
558
  AC_MSG_RESULT($glibcxx_cv_LFS)
559
  CXXFLAGS="$ac_save_CXXFLAGS"
560
  AC_LANG_RESTORE
561
])
562
 
563
 
564
dnl
565
dnl Check for whether a fully dynamic basic_string implementation should
566
dnl be turned on, that does not put empty objects in per-process static
567
dnl memory (mostly useful together with shared memory allocators, see PR
568
dnl libstdc++/16612 for details).
569
dnl
570
dnl --enable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 1
571
dnl --disable-fully-dynamic-string defines _GLIBCXX_FULLY_DYNAMIC_STRING to 0
572
dnl otherwise undefined
573
dnl  +  Usage:  GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING[(DEFAULT)]
574
dnl       Where DEFAULT is either `yes' or `no'.
575
dnl
576
AC_DEFUN([GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING], [
577
  GLIBCXX_ENABLE(fully-dynamic-string,$1,,[do not put empty strings in per-process static memory])
578
  if test $enable_fully_dynamic_string = yes; then
579
    enable_fully_dynamic_string_def=1
580
  else
581
    enable_fully_dynamic_string_def=0
582
  fi
583
  AC_DEFINE_UNQUOTED([_GLIBCXX_FULLY_DYNAMIC_STRING], [${enable_fully_dynamic_string_def}],
584
              [Define to 1 if a fully dynamic basic_string is wanted, 0 to disable, undefined for platform defaults])
585
])
586
 
587
 
588
dnl
589
dnl Does any necessary configuration of the testsuite directory.  Generates
590
dnl the testsuite_hooks.h header.
591
dnl
592
dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_IS_NATIVE must be done before this.
593
dnl
594
dnl Sets:
595
dnl  enable_abi_check
596
dnl  GLIBCXX_TEST_WCHAR_T
597
dnl  GLIBCXX_TEST_THREAD
598
dnl Substs:
599
dnl  baseline_dir
600
dnl  baseline_subdir_switch
601
dnl
602
AC_DEFUN([GLIBCXX_CONFIGURE_TESTSUITE], [
603
  if $GLIBCXX_IS_NATIVE ; then
604
    # Do checks for resource limit functions.
605
    GLIBCXX_CHECK_SETRLIMIT
606
 
607
    # Look for setenv, so that extended locale tests can be performed.
608
    GLIBCXX_CHECK_STDLIB_DECL_AND_LINKAGE_3(setenv)
609
  fi
610
 
611
  if $GLIBCXX_IS_NATIVE && test $is_hosted = yes &&
612
     test $enable_symvers != no; then
613
    case "$host" in
614
      *-*-cygwin*)
615
        enable_abi_check=no ;;
616
      *)
617
        enable_abi_check=yes ;;
618
    esac
619
  else
620
    # Only build this as native, since automake does not understand
621
    # CXX_FOR_BUILD.
622
    enable_abi_check=no
623
  fi
624
 
625
  # Export file names for ABI checking.
626
  baseline_dir="$glibcxx_srcdir/config/abi/post/${abi_baseline_pair}"
627
  AC_SUBST(baseline_dir)
628
  baseline_subdir_switch="$abi_baseline_subdir_switch"
629
  AC_SUBST(baseline_subdir_switch)
630
])
631
 
632
 
633
dnl
634
dnl Does any necessary configuration for docbook in the docs directory.
635
dnl
636
dnl XSLTPROC must be set before this
637
dnl
638
dnl Sets:
639
dnl  glibcxx_stylesheets
640
dnl Substs:
641
dnl  XSL_STYLE_DIR
642
dnl
643
AC_DEFUN([GLIBCXX_CONFIGURE_DOCBOOK], [
644
 
645
AC_MSG_CHECKING([for docbook stylesheets for documentation creation])
646
glibcxx_stylesheets=no
647
if test x${XSLTPROC} = xyes && echo '<title/>' | xsltproc --noout --nonet --xinclude http://docbook.sourceforge.net/release/xsl-ns/current/xhtml-1_1/docbook.xsl - 2>/dev/null; then
648
  glibcxx_stylesheets=yes
649
fi
650
AC_MSG_RESULT($glibcxx_stylesheets)
651
 
652
AC_MSG_CHECKING([for local stylesheet directory])
653
glibcxx_local_stylesheets=no
654
if test x"$glibcxx_stylesheets" = x"yes"; then
655
  if test -d /usr/share/sgml/docbook/xsl-ns-stylesheets; then
656
    glibcxx_local_stylesheets=yes
657
    XSL_STYLE_DIR=/usr/share/sgml/docbook/xsl-ns-stylesheets
658
  fi
659
  if test -d /usr/share/xml/docbook/stylesheet/docbook-xsl-ns; then
660
    glibcxx_local_stylesheets=yes
661
    XSL_STYLE_DIR=/usr/share/xml/docbook/stylesheet/docbook-xsl-ns
662
  fi
663
fi
664
AC_MSG_RESULT($glibcxx_local_stylesheets)
665
 
666
if test x"$glibcxx_local_stylesheets" = x"yes"; then
667
  AC_SUBST(XSL_STYLE_DIR)
668
  AC_MSG_NOTICE($XSL_STYLE_DIR)
669
else
670
  glibcxx_stylesheets=no
671
fi
672
 
673
# Check for epub3 dependencies.
674
AC_MSG_CHECKING([for epub3 stylesheets for documentation creation])
675
glibcxx_epub_stylesheets=no
676
if test x"$glibcxx_local_stylesheets" = x"yes"; then
677
   if test -f "$XSL_STYLE_DIR/epub3/chunk.xsl"; then
678
      glibcxx_epub_stylesheets=yes
679
   fi
680
fi
681
AC_MSG_RESULT($glibcxx_epub_stylesheets)
682
AM_CONDITIONAL(BUILD_EPUB, test x"$glibcxx_epub_stylesheets" = x"yes")
683
 
684
])
685
 
686
 
687
dnl
688
dnl Set up *_INCLUDES variables for all sundry Makefile.am's.
689
dnl
690
dnl Substs:
691
dnl  GLIBCXX_INCLUDES
692
dnl  TOPLEVEL_INCLUDES
693
dnl
694
AC_DEFUN([GLIBCXX_EXPORT_INCLUDES], [
695
  # Used for every C++ compile we perform.
696
  GLIBCXX_INCLUDES="\
697
-I$glibcxx_builddir/include/$host_alias \
698
-I$glibcxx_builddir/include \
699
-I$glibcxx_srcdir/libsupc++"
700
 
701
  # For Canadian crosses, pick this up too.
702
  if test $CANADIAN = yes; then
703
    GLIBCXX_INCLUDES="$GLIBCXX_INCLUDES -I\${includedir}"
704
  fi
705
 
706
  # Stuff in the actual top level.  Currently only used by libsupc++ to
707
  # get unwind* headers from the libgcc dir.
708
  #TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc -I$(toplevel_srcdir)/include'
709
  TOPLEVEL_INCLUDES='-I$(toplevel_srcdir)/libgcc'
710
 
711
  # Now, export this to all the little Makefiles....
712
  AC_SUBST(GLIBCXX_INCLUDES)
713
  AC_SUBST(TOPLEVEL_INCLUDES)
714
])
715
 
716
 
717
dnl
718
dnl Set up *_FLAGS and *FLAGS variables for all sundry Makefile.am's.
719
dnl (SECTION_FLAGS is done under CHECK_COMPILER_FEATURES.)
720
dnl
721
dnl Substs:
722
dnl  OPTIMIZE_CXXFLAGS
723
dnl  WARN_FLAGS
724
dnl
725
AC_DEFUN([GLIBCXX_EXPORT_FLAGS], [
726
  # Optimization flags that are probably a good idea for thrill-seekers. Just
727
  # uncomment the lines below and make, everything else is ready to go...
728
  # Alternatively OPTIMIZE_CXXFLAGS can be set in configure.host.
729
  # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
730
  AC_SUBST(OPTIMIZE_CXXFLAGS)
731
 
732
  WARN_FLAGS='-Wall -Wextra -Wwrite-strings -Wcast-qual -Wabi'
733
  AC_SUBST(WARN_FLAGS)
734
])
735
 
736
 
737
dnl
738
dnl All installation directory information is determined here.
739
dnl
740
dnl Substs:
741
dnl  gxx_install_dir
742
dnl  glibcxx_prefixdir
743
dnl  glibcxx_toolexecdir
744
dnl  glibcxx_toolexeclibdir
745
dnl
746
dnl Assumes cross_compiling bits already done, and with_cross_host in
747
dnl particular.
748
dnl
749
dnl This logic must match gcc/configure.ac's setting of gcc_gxx_include_dir.
750
dnl config/gxx-include-dir.m4 must be kept consistant with this as well.
751
AC_DEFUN([GLIBCXX_EXPORT_INSTALL_INFO], [
752
  glibcxx_toolexecdir=no
753
  glibcxx_toolexeclibdir=no
754
  glibcxx_prefixdir=$prefix
755
 
756
  AC_MSG_CHECKING([for gxx-include-dir])
757
  AC_ARG_WITH([gxx-include-dir],
758
    AC_HELP_STRING([--with-gxx-include-dir=DIR],
759
                   [installation directory for include files]),
760
    [case "$withval" in
761
      yes) AC_MSG_ERROR([Missing directory for --with-gxx-include-dir]) ;;
762
      no)  gxx_include_dir=no ;;
763
      *)   gxx_include_dir=$withval ;;
764
     esac],
765
    [gxx_include_dir=no])
766
  AC_MSG_RESULT($gxx_include_dir)
767
 
768
  AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
769
  AC_ARG_ENABLE([version-specific-runtime-libs],
770
    AC_HELP_STRING([--enable-version-specific-runtime-libs],
771
                   [Specify that runtime libraries should be installed in a compiler-specific directory]),
772
    [case "$enableval" in
773
      yes) version_specific_libs=yes ;;
774
      no)  version_specific_libs=no ;;
775
      *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
776
     esac],
777
    [version_specific_libs=no])
778
  AC_MSG_RESULT($version_specific_libs)
779
 
780
  # Default case for install directory for include files.
781
  if test $version_specific_libs = no && test $gxx_include_dir = no; then
782
    gxx_include_dir='include/c++/${gcc_version}'
783
    if test -n "$with_cross_host" &&
784
       test x"$with_cross_host" != x"no"; then
785
      gxx_include_dir='${prefix}/${target_alias}/'"$gxx_include_dir"
786
    else
787
      gxx_include_dir='${prefix}/'"$gxx_include_dir"
788
    fi
789
  fi
790
 
791
  # Version-specific runtime libs processing.
792
  if test $version_specific_libs = yes; then
793
    # Need the gcc compiler version to know where to install libraries
794
    # and header files if --enable-version-specific-runtime-libs option
795
    # is selected.  FIXME: these variables are misnamed, there are
796
    # no executables installed in _toolexecdir or _toolexeclibdir.
797
    if test x"$gxx_include_dir" = x"no"; then
798
      gxx_include_dir='${libdir}/gcc/${host_alias}/${gcc_version}/include/c++'
799
    fi
800
    glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
801
    glibcxx_toolexeclibdir='${toolexecdir}/${gcc_version}$(MULTISUBDIR)'
802
  fi
803
 
804
  # Calculate glibcxx_toolexecdir, glibcxx_toolexeclibdir
805
  # Install a library built with a cross compiler in tooldir, not libdir.
806
  if test x"$glibcxx_toolexecdir" = x"no"; then
807
    if test -n "$with_cross_host" &&
808
       test x"$with_cross_host" != x"no"; then
809
      glibcxx_toolexecdir='${exec_prefix}/${host_alias}'
810
      glibcxx_toolexeclibdir='${toolexecdir}/lib'
811
    else
812
      glibcxx_toolexecdir='${libdir}/gcc/${host_alias}'
813
      glibcxx_toolexeclibdir='${libdir}'
814
    fi
815
    multi_os_directory=`$CXX -print-multi-os-directory`
816
    case $multi_os_directory in
817
      .) ;; # Avoid trailing /.
818
      *) glibcxx_toolexeclibdir=$glibcxx_toolexeclibdir/$multi_os_directory ;;
819
    esac
820
  fi
821
 
822
  AC_MSG_CHECKING([for install location])
823
  AC_MSG_RESULT($gxx_include_dir)
824
 
825
  AC_SUBST(glibcxx_prefixdir)
826
  AC_SUBST(gxx_include_dir)
827
  AC_SUBST(glibcxx_toolexecdir)
828
  AC_SUBST(glibcxx_toolexeclibdir)
829
])
830
 
831
 
832
dnl
833
dnl GLIBCXX_ENABLE
834
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
835
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
836
dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
837
dnl
838
dnl See docs/html/17_intro/configury.html#enable for documentation.
839
dnl
840
m4_define([GLIBCXX_ENABLE],[dnl
841
m4_define([_g_switch],[--enable-$1])dnl
842
m4_define([_g_help],[AC_HELP_STRING([_g_switch$3],[$4 @<:@default=$2@:>@])])dnl
843
 AC_ARG_ENABLE([$1],m4_dquote(_g_help),
844
  m4_bmatch([$5],
845
   [^permit ],
846
     [[
847
      case "$enableval" in
848
       m4_bpatsubst([$5],[permit ])) ;;
849
       *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
850
          dnl Idea for future:  generate a URL pointing to
851
          dnl "onlinedocs/configopts.html#whatever"
852
      esac
853
     ]],
854
   [^$],
855
     [[
856
      case "$enableval" in
857
       yes|no) ;;
858
       *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
859
      esac
860
     ]],
861
   [[$5]]),
862
  [enable_]m4_bpatsubst([$1],-,_)[=][$2])
863
m4_undefine([_g_switch])dnl
864
m4_undefine([_g_help])dnl
865
])
866
 
867
 
868
dnl
869
dnl Check for ISO/IEC 9899:1999 "C99" support.
870
dnl
871
dnl --enable-c99 defines _GLIBCXX_USE_C99
872
dnl --disable-c99 leaves _GLIBCXX_USE_C99 undefined
873
dnl  +  Usage:  GLIBCXX_ENABLE_C99[(DEFAULT)]
874
dnl       Where DEFAULT is either `yes' or `no'.
875
dnl  +  If 'C99' stuff is not available, ignores DEFAULT and sets `no'.
876
dnl
877
AC_DEFUN([GLIBCXX_ENABLE_C99], [
878
  GLIBCXX_ENABLE(c99,$1,,[turns on ISO/IEC 9899:1999 support])
879
 
880
  if test x"$enable_c99" = x"yes"; then
881
 
882
  AC_LANG_SAVE
883
  AC_LANG_CPLUSPLUS
884
 
885
  # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
886
  # undefined and fake C99 facilities - like pre-standard snprintf - may be
887
  # spuriously enabled.
888
  # Long term, -std=c++0x could be even better, could manage to explicitely
889
  # request C99 facilities to the underlying C headers.
890
  ac_save_CXXFLAGS="$CXXFLAGS"
891
  CXXFLAGS="$CXXFLAGS -std=c++98"
892
  ac_save_LIBS="$LIBS"
893
  ac_save_gcc_no_link="$gcc_no_link"
894
 
895
  if test x$gcc_no_link != xyes; then
896
    # Use -fno-exceptions to that the C driver can link these tests without
897
    # hitting undefined references to personality routines.
898
    CXXFLAGS="$CXXFLAGS -fno-exceptions"
899
    AC_CHECK_LIB(m, sin, [
900
      LIBS="$LIBS -lm"
901
    ], [
902
      # Use the default compile-only tests in GCC_TRY_COMPILE_OR_LINK
903
      gcc_no_link=yes
904
    ])
905
  fi
906
 
907
  # Check for the existence of <math.h> functions used if C99 is enabled.
908
  AC_MSG_CHECKING([for ISO C99 support in <math.h>])
909
  AC_CACHE_VAL(glibcxx_cv_c99_math, [
910
  GCC_TRY_COMPILE_OR_LINK(
911
     [#include <math.h>
912
      volatile double d1, d2;
913
      volatile int i;],
914
     [i = fpclassify(d1);
915
      i = isfinite(d1);
916
      i = isinf(d1);
917
      i = isnan(d1);
918
      i = isnormal(d1);
919
      i = signbit(d1);
920
      i = isgreater(d1, d2);
921
      i = isgreaterequal(d1, d2);
922
      i = isless(d1, d2);
923
      i = islessequal(d1, d2);
924
      i = islessgreater(d1, d2);
925
      i = islessgreater(d1, d2);
926
      i = isunordered(d1, d2);
927
     ],[glibcxx_cv_c99_math=yes], [glibcxx_cv_c99_math=no])
928
  ])
929
  AC_MSG_RESULT($glibcxx_cv_c99_math)
930
  if test x"$glibcxx_cv_c99_math" = x"yes"; then
931
    AC_DEFINE(_GLIBCXX_USE_C99_MATH, 1,
932
              [Define if C99 functions or macros in <math.h> should be imported
933
              in <cmath> in namespace std.])
934
  fi
935
 
936
  # Check for the existence of <complex.h> complex math functions.
937
  # This is necessary even though libstdc++ uses the builtin versions
938
  # of these functions, because if the builtin cannot be used, a reference
939
  # to the library function is emitted.
940
  AC_CHECK_HEADERS(tgmath.h, ac_has_tgmath_h=yes, ac_has_tgmath_h=no)
941
  AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
942
  glibcxx_cv_c99_complex=no;
943
  if test x"$ac_has_complex_h" = x"yes"; then
944
    AC_MSG_CHECKING([for ISO C99 support in <complex.h>])
945
    GCC_TRY_COMPILE_OR_LINK(
946
       [#include <complex.h>
947
        typedef __complex__ float float_type;
948
        typedef __complex__ double double_type;
949
        typedef __complex__ long double ld_type;
950
        volatile float_type tmpf;
951
        volatile double_type tmpd;
952
        volatile ld_type tmpld;
953
        volatile float f;
954
        volatile double d;
955
        volatile long double ld;],
956
       [f = cabsf(tmpf);
957
        f = cargf(tmpf);
958
        tmpf = ccosf(tmpf);
959
        tmpf = ccoshf(tmpf);
960
        tmpf = cexpf(tmpf);
961
        tmpf = clogf(tmpf);
962
        tmpf = csinf(tmpf);
963
        tmpf = csinhf(tmpf);
964
        tmpf = csqrtf(tmpf);
965
        tmpf = ctanf(tmpf);
966
        tmpf = ctanhf(tmpf);
967
        tmpf = cpowf(tmpf, tmpf);
968
        tmpf = cprojf(tmpf);
969
        d = cabs(tmpd);
970
        d = carg(tmpd);
971
        tmpd = ccos(tmpd);
972
        tmpd = ccosh(tmpd);
973
        tmpd = cexp(tmpd);
974
        tmpd = clog(tmpd);
975
        tmpd = csin(tmpd);
976
        tmpd = csinh(tmpd);
977
        tmpd = csqrt(tmpd);
978
        tmpd = ctan(tmpd);
979
        tmpd = ctanh(tmpd);
980
        tmpd = cpow(tmpd, tmpd);
981
        tmpd = cproj(tmpd);
982
        ld = cabsl(tmpld);
983
        ld = cargl(tmpld);
984
        tmpld = ccosl(tmpld);
985
        tmpld = ccoshl(tmpld);
986
        tmpld = cexpl(tmpld);
987
        tmpld = clogl(tmpld);
988
        tmpld = csinl(tmpld);
989
        tmpld = csinhl(tmpld);
990
        tmpld = csqrtl(tmpld);
991
        tmpld = ctanl(tmpld);
992
        tmpld = ctanhl(tmpld);
993
        tmpld = cpowl(tmpld, tmpld);
994
        tmpld = cprojl(tmpld);
995
       ],[glibcxx_cv_c99_complex=yes], [glibcxx_cv_c99_complex=no])
996
  fi
997
  AC_MSG_RESULT($glibcxx_cv_c99_complex)
998
  if test x"$glibcxx_cv_c99_complex" = x"yes"; then
999
    AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX, 1,
1000
              [Define if C99 functions in <complex.h> should be used in
1001
              <complex>. Using compiler builtins for these functions requires
1002
              corresponding C99 library functions to be present.])
1003
  fi
1004
 
1005
  # Check for the existence in <stdio.h> of vscanf, et. al.
1006
  AC_MSG_CHECKING([for ISO C99 support in <stdio.h>])
1007
  AC_CACHE_VAL(glibcxx_cv_c99_stdio, [
1008
  GCC_TRY_COMPILE_OR_LINK(
1009
     [#include <stdio.h>
1010
      #include <stdarg.h>
1011
      void foo(char* fmt, ...)
1012
      {
1013
        va_list args; va_start(args, fmt);
1014
        vfscanf(stderr, "%i", args);
1015
        vscanf("%i", args);
1016
        vsnprintf(fmt, 0, "%i", args);
1017
        vsscanf(fmt, "%i", args);
1018
      }],
1019
     [snprintf("12", 0, "%i");],
1020
     [glibcxx_cv_c99_stdio=yes], [glibcxx_cv_c99_stdio=no])
1021
  ])
1022
  AC_MSG_RESULT($glibcxx_cv_c99_stdio)
1023
 
1024
  # Check for the existence in <stdlib.h> of lldiv_t, et. al.
1025
  AC_MSG_CHECKING([for ISO C99 support in <stdlib.h>])
1026
  AC_CACHE_VAL(glibcxx_cv_c99_stdlib, [
1027
  GCC_TRY_COMPILE_OR_LINK(
1028
     [#include <stdlib.h>
1029
      volatile float f;
1030
      volatile long double ld;
1031
      volatile unsigned long long ll;
1032
      lldiv_t mydivt;],
1033
     [char* tmp;
1034
      f = strtof("gnu", &tmp);
1035
      ld = strtold("gnu", &tmp);
1036
      ll = strtoll("gnu", &tmp, 10);
1037
      ll = strtoull("gnu", &tmp, 10);
1038
      ll = llabs(10);
1039
      mydivt = lldiv(10,1);
1040
      ll = mydivt.quot;
1041
      ll = mydivt.rem;
1042
      ll = atoll("10");
1043
      _Exit(0);
1044
      ],[glibcxx_cv_c99_stdlib=yes], [glibcxx_cv_c99_stdlib=no])
1045
  ])
1046
  AC_MSG_RESULT($glibcxx_cv_c99_stdlib)
1047
 
1048
  # Check for the existence in <wchar.h> of wcstold, etc.
1049
  glibcxx_cv_c99_wchar=no;
1050
  if test x"$ac_has_wchar_h" = xyes &&
1051
     test x"$ac_has_wctype_h" = xyes; then
1052
    AC_MSG_CHECKING([for ISO C99 support in <wchar.h>])
1053
    AC_TRY_COMPILE([#include <wchar.h>
1054
                    namespace test
1055
                    {
1056
                      using ::wcstold;
1057
                      using ::wcstoll;
1058
                      using ::wcstoull;
1059
                    }
1060
                   ],[],[glibcxx_cv_c99_wchar=yes], [glibcxx_cv_c99_wchar=no])
1061
 
1062
    # Checks for wide character functions that may not be present.
1063
    # Injection of these is wrapped with guard macros.
1064
    # NB: only put functions here, instead of immediately above, if
1065
    # absolutely necessary.
1066
    AC_TRY_COMPILE([#include <wchar.h>
1067
                    namespace test { using ::vfwscanf; } ], [],
1068
                   [AC_DEFINE(HAVE_VFWSCANF,1,
1069
                        [Defined if vfwscanf exists.])],[])
1070
 
1071
    AC_TRY_COMPILE([#include <wchar.h>
1072
                    namespace test { using ::vswscanf; } ], [],
1073
                   [AC_DEFINE(HAVE_VSWSCANF,1,
1074
                        [Defined if vswscanf exists.])],[])
1075
 
1076
    AC_TRY_COMPILE([#include <wchar.h>
1077
                    namespace test { using ::vwscanf; } ], [],
1078
                   [AC_DEFINE(HAVE_VWSCANF,1,[Defined if vwscanf exists.])],[])
1079
 
1080
    AC_TRY_COMPILE([#include <wchar.h>
1081
                    namespace test { using ::wcstof; } ], [],
1082
                   [AC_DEFINE(HAVE_WCSTOF,1,[Defined if wcstof exists.])],[])
1083
 
1084
    AC_TRY_COMPILE([#include <wctype.h>],
1085
                   [ wint_t t; int i = iswblank(t);],
1086
                   [AC_DEFINE(HAVE_ISWBLANK,1,
1087
                        [Defined if iswblank exists.])],[])
1088
 
1089
    AC_MSG_RESULT($glibcxx_cv_c99_wchar)
1090
  fi
1091
 
1092
  # Option parsed, now set things appropriately.
1093
  if test x"$glibcxx_cv_c99_math" = x"no" ||
1094
     test x"$glibcxx_cv_c99_complex" = x"no" ||
1095
     test x"$glibcxx_cv_c99_stdio" = x"no" ||
1096
     test x"$glibcxx_cv_c99_stdlib" = x"no" ||
1097
     test x"$glibcxx_cv_c99_wchar" = x"no"; then
1098
    enable_c99=no;
1099
  else
1100
    AC_DEFINE(_GLIBCXX_USE_C99, 1,
1101
    [Define if C99 functions or macros from <wchar.h>, <math.h>,
1102
    <complex.h>, <stdio.h>, and <stdlib.h> can be used or exposed.])
1103
  fi
1104
 
1105
  gcc_no_link="$ac_save_gcc_no_link"
1106
  LIBS="$ac_save_LIBS"
1107
  CXXFLAGS="$ac_save_CXXFLAGS"
1108
  AC_LANG_RESTORE
1109
  fi
1110
 
1111
  AC_MSG_CHECKING([for fully enabled ISO C99 support])
1112
  AC_MSG_RESULT($enable_c99)
1113
])
1114
 
1115
 
1116
dnl
1117
dnl Check for clock_gettime, nanosleep and sched_yield, used in the
1118
dnl implementation of 20.8.5 [time.clock], and 30.2.2 [thread.thread.this]
1119
dnl in the current C++0x working draft.
1120
dnl
1121
dnl --enable-libstdcxx-time
1122
dnl --enable-libstdcxx-time=yes
1123
dnl        checks for the availability of monotonic and realtime clocks,
1124
dnl        nanosleep and sched_yield in libc and libposix4 and, in case, links
1125
dnl       the latter
1126
dnl --enable-libstdcxx-time=rt
1127
dnl        also searches (and, in case, links) librt.  Note that this is
1128
dnl        not always desirable because, in glibc, for example, in turn it
1129
dnl        triggers the linking of libpthread too, which activates locking,
1130
dnl        a large overhead for single-thread programs.
1131
dnl --enable-libstdcxx-time=no
1132
dnl --disable-libstdcxx-time
1133
dnl        disables the checks completely
1134
dnl
1135
AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_TIME], [
1136
 
1137
  AC_MSG_CHECKING([for clock_gettime, nanosleep and sched_yield])
1138
  GLIBCXX_ENABLE(libstdcxx-time,$1,[[[=KIND]]],
1139
    [use KIND for check type],
1140
    [permit yes|no|rt])
1141
 
1142
  AC_LANG_SAVE
1143
  AC_LANG_CPLUSPLUS
1144
  ac_save_CXXFLAGS="$CXXFLAGS"
1145
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
1146
  ac_save_LIBS="$LIBS"
1147
 
1148
  ac_has_clock_monotonic=no
1149
  ac_has_clock_realtime=no
1150
  AC_MSG_RESULT($enable_libstdcxx_time)
1151
 
1152
  if test x"$enable_libstdcxx_time" != x"no"; then
1153
 
1154
    if test x"$enable_libstdcxx_time" = x"rt"; then
1155
      AC_SEARCH_LIBS(clock_gettime, [rt posix4])
1156
      AC_SEARCH_LIBS(nanosleep, [rt posix4])
1157
    else
1158
      AC_SEARCH_LIBS(clock_gettime, [posix4])
1159
      AC_SEARCH_LIBS(nanosleep, [posix4])
1160
    fi
1161
 
1162
    case "$ac_cv_search_clock_gettime" in
1163
      -l*) GLIBCXX_LIBS=$ac_cv_search_clock_gettime
1164
      ;;
1165
    esac
1166
    case "$ac_cv_search_nanosleep" in
1167
      -l*) GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_nanosleep"
1168
      ;;
1169
    esac
1170
 
1171
    AC_SEARCH_LIBS(sched_yield, [rt posix4])
1172
 
1173
    case "$ac_cv_search_sched_yield" in
1174
      -lposix4*)
1175
      GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1176
      AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1177
                [ Defined if sched_yield is available. ])
1178
      ;;
1179
      -lrt*)
1180
      if test x"$enable_libstdcxx_time" = x"rt"; then
1181
        GLIBCXX_LIBS="$GLIBCXX_LIBS $ac_cv_search_sched_yield"
1182
        AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1183
                  [ Defined if sched_yield is available. ])
1184
      fi
1185
      ;;
1186
      *)
1187
      AC_DEFINE(_GLIBCXX_USE_SCHED_YIELD, 1,
1188
                [ Defined if sched_yield is available. ])
1189
      ;;
1190
    esac
1191
 
1192
    AC_CHECK_HEADERS(unistd.h, ac_has_unistd_h=yes, ac_has_unistd_h=no)
1193
 
1194
    if test x"$ac_has_unistd_h" = x"yes"; then
1195
      AC_MSG_CHECKING([for monotonic clock])
1196
      AC_TRY_LINK(
1197
        [#include <unistd.h>
1198
         #include <time.h>
1199
        ],
1200
        [#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK)
1201
          timespec tp;
1202
         #endif
1203
          clock_gettime(CLOCK_MONOTONIC, &tp);
1204
        ], [ac_has_clock_monotonic=yes], [ac_has_clock_monotonic=no])
1205
 
1206
      AC_MSG_RESULT($ac_has_clock_monotonic)
1207
 
1208
      AC_MSG_CHECKING([for realtime clock])
1209
      AC_TRY_LINK(
1210
        [#include <unistd.h>
1211
         #include <time.h>
1212
        ],
1213
        [#if _POSIX_TIMERS > 0
1214
          timespec tp;
1215
         #endif
1216
          clock_gettime(CLOCK_REALTIME, &tp);
1217
        ], [ac_has_clock_realtime=yes], [ac_has_clock_realtime=no])
1218
 
1219
      AC_MSG_RESULT($ac_has_clock_realtime)
1220
 
1221
      AC_MSG_CHECKING([for nanosleep])
1222
      AC_TRY_LINK(
1223
        [#include <unistd.h>
1224
         #include <time.h>
1225
        ],
1226
        [#if _POSIX_TIMERS > 0
1227
          timespec tp;
1228
         #endif
1229
          nanosleep(&tp, 0);
1230
        ], [ac_has_nanosleep=yes], [ac_has_nanosleep=no])
1231
 
1232
      AC_MSG_RESULT($ac_has_nanosleep)
1233
    fi
1234
  fi
1235
 
1236
  if test x"$ac_has_clock_monotonic" = x"yes"; then
1237
    AC_DEFINE(_GLIBCXX_USE_CLOCK_MONOTONIC, 1,
1238
      [ Defined if clock_gettime has monotonic clock support. ])
1239
  fi
1240
 
1241
  if test x"$ac_has_clock_realtime" = x"yes"; then
1242
    AC_DEFINE(_GLIBCXX_USE_CLOCK_REALTIME, 1,
1243
      [ Defined if clock_gettime has realtime clock support. ])
1244
  fi
1245
 
1246
  if test x"$ac_has_nanosleep" = x"yes"; then
1247
    AC_DEFINE(_GLIBCXX_USE_NANOSLEEP, 1,
1248
      [ Defined if nanosleep is available. ])
1249
  fi
1250
 
1251
  AC_SUBST(GLIBCXX_LIBS)
1252
 
1253
  CXXFLAGS="$ac_save_CXXFLAGS"
1254
  LIBS="$ac_save_LIBS"
1255
  AC_LANG_RESTORE
1256
])
1257
 
1258
dnl
1259
dnl Check for gettimeofday, used in the implementation of 20.8.5
1260
dnl [time.clock] in the current C++0x working draft.
1261
dnl
1262
AC_DEFUN([GLIBCXX_CHECK_GETTIMEOFDAY], [
1263
 
1264
  AC_MSG_CHECKING([for gettimeofday])
1265
 
1266
  AC_LANG_SAVE
1267
  AC_LANG_CPLUSPLUS
1268
  ac_save_CXXFLAGS="$CXXFLAGS"
1269
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
1270
 
1271
  ac_has_gettimeofday=no;
1272
  AC_CHECK_HEADERS(sys/time.h, ac_has_sys_time_h=yes, ac_has_sys_time_h=no)
1273
  if test x"$ac_has_sys_time_h" = x"yes"; then
1274
    AC_MSG_CHECKING([for gettimeofday])
1275
    GCC_TRY_COMPILE_OR_LINK([#include <sys/time.h>],
1276
      [timeval tv; gettimeofday(&tv, 0);],
1277
      [ac_has_gettimeofday=yes], [ac_has_gettimeofday=no])
1278
 
1279
    AC_MSG_RESULT($ac_has_gettimeofday)
1280
  fi
1281
 
1282
  if test x"$ac_has_gettimeofday" = x"yes"; then
1283
    AC_DEFINE(_GLIBCXX_USE_GETTIMEOFDAY, 1,
1284
      [ Defined if gettimeofday is available. ])
1285
  fi
1286
 
1287
  CXXFLAGS="$ac_save_CXXFLAGS"
1288
  AC_LANG_RESTORE
1289
])
1290
 
1291
dnl
1292
dnl Check for ISO/IEC 9899:1999 "C99" support to ISO/IEC DTR 19768 "TR1"
1293
dnl facilities in Chapter 8, "C compatibility".
1294
dnl
1295
AC_DEFUN([GLIBCXX_CHECK_C99_TR1], [
1296
 
1297
  AC_LANG_SAVE
1298
  AC_LANG_CPLUSPLUS
1299
 
1300
  # Use -std=c++98 because the default (-std=gnu++98) leaves __STRICT_ANSI__
1301
  # undefined and fake C99 facilities may be spuriously enabled.
1302
  ac_save_CXXFLAGS="$CXXFLAGS"
1303
  CXXFLAGS="$CXXFLAGS -std=c++98"
1304
 
1305
  # Check for the existence of <complex.h> complex math functions used
1306
  # by tr1/complex.
1307
  AC_CHECK_HEADERS(complex.h, ac_has_complex_h=yes, ac_has_complex_h=no)
1308
  ac_c99_complex_tr1=no;
1309
  if test x"$ac_has_complex_h" = x"yes"; then
1310
    AC_MSG_CHECKING([for ISO C99 support to TR1 in <complex.h>])
1311
    AC_TRY_COMPILE([#include <complex.h>],
1312
                   [typedef __complex__ float float_type; float_type tmpf;
1313
                    cacosf(tmpf);
1314
                    casinf(tmpf);
1315
                    catanf(tmpf);
1316
                    cacoshf(tmpf);
1317
                    casinhf(tmpf);
1318
                    catanhf(tmpf);
1319
                    typedef __complex__ double double_type; double_type tmpd;
1320
                    cacos(tmpd);
1321
                    casin(tmpd);
1322
                    catan(tmpd);
1323
                    cacosh(tmpd);
1324
                    casinh(tmpd);
1325
                    catanh(tmpd);
1326
                    typedef __complex__ long double ld_type; ld_type tmpld;
1327
                    cacosl(tmpld);
1328
                    casinl(tmpld);
1329
                    catanl(tmpld);
1330
                    cacoshl(tmpld);
1331
                    casinhl(tmpld);
1332
                    catanhl(tmpld);
1333
                   ],[ac_c99_complex_tr1=yes], [ac_c99_complex_tr1=no])
1334
  fi
1335
  AC_MSG_RESULT($ac_c99_complex_tr1)
1336
  if test x"$ac_c99_complex_tr1" = x"yes"; then
1337
    AC_DEFINE(_GLIBCXX_USE_C99_COMPLEX_TR1, 1,
1338
              [Define if C99 functions in <complex.h> should be used in
1339
              <tr1/complex>. Using compiler builtins for these functions
1340
              requires corresponding C99 library functions to be present.])
1341
  fi
1342
 
1343
  # Check for the existence of <ctype.h> functions.
1344
  AC_MSG_CHECKING([for ISO C99 support to TR1 in <ctype.h>])
1345
  AC_CACHE_VAL(glibcxx_cv_c99_ctype_tr1, [
1346
  AC_TRY_COMPILE([#include <ctype.h>],
1347
                 [int ch;
1348
                  int ret;
1349
                  ret = isblank(ch);
1350
                 ],[glibcxx_cv_c99_ctype_tr1=yes],
1351
                   [glibcxx_cv_c99_ctype_tr1=no])
1352
  ])
1353
  AC_MSG_RESULT($glibcxx_cv_c99_ctype_tr1)
1354
  if test x"$glibcxx_cv_c99_ctype_tr1" = x"yes"; then
1355
    AC_DEFINE(_GLIBCXX_USE_C99_CTYPE_TR1, 1,
1356
              [Define if C99 functions in <ctype.h> should be imported in
1357
              <tr1/cctype> in namespace std::tr1.])
1358
  fi
1359
 
1360
  # Check for the existence of <fenv.h> functions.
1361
  AC_CHECK_HEADERS(fenv.h, ac_has_fenv_h=yes, ac_has_fenv_h=no)
1362
  ac_c99_fenv_tr1=no;
1363
  if test x"$ac_has_fenv_h" = x"yes"; then
1364
    AC_MSG_CHECKING([for ISO C99 support to TR1 in <fenv.h>])
1365
    AC_TRY_COMPILE([#include <fenv.h>],
1366
                   [int except, mode;
1367
                    fexcept_t* pflag;
1368
                    fenv_t* penv;
1369
                    int ret;
1370
                    ret = feclearexcept(except);
1371
                    ret = fegetexceptflag(pflag, except);
1372
                    ret = feraiseexcept(except);
1373
                    ret = fesetexceptflag(pflag, except);
1374
                    ret = fetestexcept(except);
1375
                    ret = fegetround();
1376
                    ret = fesetround(mode);
1377
                    ret = fegetenv(penv);
1378
                    ret = feholdexcept(penv);
1379
                    ret = fesetenv(penv);
1380
                    ret = feupdateenv(penv);
1381
                   ],[ac_c99_fenv_tr1=yes], [ac_c99_fenv_tr1=no])
1382
  fi
1383
  AC_MSG_RESULT($ac_c99_fenv_tr1)
1384
  if test x"$ac_c99_fenv_tr1" = x"yes"; then
1385
    AC_DEFINE(_GLIBCXX_USE_C99_FENV_TR1, 1,
1386
              [Define if C99 functions in <fenv.h> should be imported in
1387
              <tr1/cfenv> in namespace std::tr1.])
1388
  fi
1389
 
1390
  # Check for the existence of <stdint.h> types.
1391
  AC_MSG_CHECKING([for ISO C99 support to TR1 in <stdint.h>])
1392
  AC_CACHE_VAL(glibcxx_cv_c99_stdint_tr1, [
1393
  AC_TRY_COMPILE([#define __STDC_LIMIT_MACROS
1394
                  #define __STDC_CONSTANT_MACROS
1395
                  #include <stdint.h>],
1396
                 [typedef int8_t          my_int8_t;
1397
                  my_int8_t               i8 = INT8_MIN;
1398
                  i8 = INT8_MAX;
1399
                  typedef int16_t         my_int16_t;
1400
                  my_int16_t              i16 = INT16_MIN;
1401
                  i16 = INT16_MAX;
1402
                  typedef int32_t         my_int32_t;
1403
                  my_int32_t              i32 = INT32_MIN;
1404
                  i32 = INT32_MAX;
1405
                  typedef int64_t         my_int64_t;
1406
                  my_int64_t              i64 = INT64_MIN;
1407
                  i64 = INT64_MAX;
1408
                  typedef int_fast8_t     my_int_fast8_t;
1409
                  my_int_fast8_t          if8 = INT_FAST8_MIN;
1410
                  if8 = INT_FAST8_MAX;
1411
                  typedef int_fast16_t    my_int_fast16_t;
1412
                  my_int_fast16_t         if16 = INT_FAST16_MIN;
1413
                  if16 = INT_FAST16_MAX;
1414
                  typedef int_fast32_t    my_int_fast32_t;
1415
                  my_int_fast32_t         if32 = INT_FAST32_MIN;
1416
                  if32 = INT_FAST32_MAX;
1417
                  typedef int_fast64_t    my_int_fast64_t;
1418
                  my_int_fast64_t         if64 = INT_FAST64_MIN;
1419
                  if64 = INT_FAST64_MAX;
1420
                  typedef int_least8_t    my_int_least8_t;
1421
                  my_int_least8_t         il8 = INT_LEAST8_MIN;
1422
                  il8 = INT_LEAST8_MAX;
1423
                  typedef int_least16_t   my_int_least16_t;
1424
                  my_int_least16_t        il16 = INT_LEAST16_MIN;
1425
                  il16 = INT_LEAST16_MAX;
1426
                  typedef int_least32_t   my_int_least32_t;
1427
                  my_int_least32_t        il32 = INT_LEAST32_MIN;
1428
                  il32 = INT_LEAST32_MAX;
1429
                  typedef int_least64_t   my_int_least64_t;
1430
                  my_int_least64_t        il64 = INT_LEAST64_MIN;
1431
                  il64 = INT_LEAST64_MAX;
1432
                  typedef intmax_t        my_intmax_t;
1433
                  my_intmax_t             im = INTMAX_MAX;
1434
                  im = INTMAX_MIN;
1435
                  typedef intptr_t        my_intptr_t;
1436
                  my_intptr_t             ip = INTPTR_MAX;
1437
                  ip = INTPTR_MIN;
1438
                  typedef uint8_t         my_uint8_t;
1439
                  my_uint8_t              ui8 = UINT8_MAX;
1440
                  ui8 = UINT8_MAX;
1441
                  typedef uint16_t        my_uint16_t;
1442
                  my_uint16_t             ui16 = UINT16_MAX;
1443
                  ui16 = UINT16_MAX;
1444
                  typedef uint32_t        my_uint32_t;
1445
                  my_uint32_t             ui32 = UINT32_MAX;
1446
                  ui32 = UINT32_MAX;
1447
                  typedef uint64_t        my_uint64_t;
1448
                  my_uint64_t             ui64 = UINT64_MAX;
1449
                  ui64 = UINT64_MAX;
1450
                  typedef uint_fast8_t    my_uint_fast8_t;
1451
                  my_uint_fast8_t         uif8 = UINT_FAST8_MAX;
1452
                  uif8 = UINT_FAST8_MAX;
1453
                  typedef uint_fast16_t   my_uint_fast16_t;
1454
                  my_uint_fast16_t        uif16 = UINT_FAST16_MAX;
1455
                  uif16 = UINT_FAST16_MAX;
1456
                  typedef uint_fast32_t   my_uint_fast32_t;
1457
                  my_uint_fast32_t        uif32 = UINT_FAST32_MAX;
1458
                  uif32 = UINT_FAST32_MAX;
1459
                  typedef uint_fast64_t   my_uint_fast64_t;
1460
                  my_uint_fast64_t        uif64 = UINT_FAST64_MAX;
1461
                  uif64 = UINT_FAST64_MAX;
1462
                  typedef uint_least8_t   my_uint_least8_t;
1463
                  my_uint_least8_t        uil8 = UINT_LEAST8_MAX;
1464
                  uil8 = UINT_LEAST8_MAX;
1465
                  typedef uint_least16_t  my_uint_least16_t;
1466
                  my_uint_least16_t       uil16 = UINT_LEAST16_MAX;
1467
                  uil16 = UINT_LEAST16_MAX;
1468
                  typedef uint_least32_t  my_uint_least32_t;
1469
                  my_uint_least32_t       uil32 = UINT_LEAST32_MAX;
1470
                  uil32 = UINT_LEAST32_MAX;
1471
                  typedef uint_least64_t  my_uint_least64_t;
1472
                  my_uint_least64_t       uil64 = UINT_LEAST64_MAX;
1473
                  uil64 = UINT_LEAST64_MAX;
1474
                  typedef uintmax_t       my_uintmax_t;
1475
                  my_uintmax_t            uim = UINTMAX_MAX;
1476
                  uim = UINTMAX_MAX;
1477
                  typedef uintptr_t       my_uintptr_t;
1478
                  my_uintptr_t            uip = UINTPTR_MAX;
1479
                  uip = UINTPTR_MAX;
1480
                 ],[glibcxx_cv_c99_stdint_tr1=yes],
1481
                   [glibcxx_cv_c99_stdint_tr1=no])
1482
  ])
1483
  AC_MSG_RESULT($glibcxx_cv_c99_stdint_tr1)
1484
  if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1485
    AC_DEFINE(_GLIBCXX_USE_C99_STDINT_TR1, 1,
1486
              [Define if C99 types in <stdint.h> should be imported in
1487
              <tr1/cstdint> in namespace std::tr1.])
1488
  fi
1489
 
1490
  # Check for the existence of <math.h> functions.
1491
  AC_MSG_CHECKING([for ISO C99 support to TR1 in <math.h>])
1492
  AC_CACHE_VAL(glibcxx_cv_c99_math_tr1, [
1493
  AC_TRY_COMPILE([#include <math.h>],
1494
                 [typedef double_t  my_double_t;
1495
                  typedef float_t   my_float_t;
1496
                  acosh(0.0);
1497
                  acoshf(0.0f);
1498
                  acoshl(0.0l);
1499
                  asinh(0.0);
1500
                  asinhf(0.0f);
1501
                  asinhl(0.0l);
1502
                  atanh(0.0);
1503
                  atanhf(0.0f);
1504
                  atanhl(0.0l);
1505
                  cbrt(0.0);
1506
                  cbrtf(0.0f);
1507
                  cbrtl(0.0l);
1508
                  copysign(0.0, 0.0);
1509
                  copysignf(0.0f, 0.0f);
1510
                  copysignl(0.0l, 0.0l);
1511
                  erf(0.0);
1512
                  erff(0.0f);
1513
                  erfl(0.0l);
1514
                  erfc(0.0);
1515
                  erfcf(0.0f);
1516
                  erfcl(0.0l);
1517
                  exp2(0.0);
1518
                  exp2f(0.0f);
1519
                  exp2l(0.0l);
1520
                  expm1(0.0);
1521
                  expm1f(0.0f);
1522
                  expm1l(0.0l);
1523
                  fdim(0.0, 0.0);
1524
                  fdimf(0.0f, 0.0f);
1525
                  fdiml(0.0l, 0.0l);
1526
                  fma(0.0, 0.0, 0.0);
1527
                  fmaf(0.0f, 0.0f, 0.0f);
1528
                  fmal(0.0l, 0.0l, 0.0l);
1529
                  fmax(0.0, 0.0);
1530
                  fmaxf(0.0f, 0.0f);
1531
                  fmaxl(0.0l, 0.0l);
1532
                  fmin(0.0, 0.0);
1533
                  fminf(0.0f, 0.0f);
1534
                  fminl(0.0l, 0.0l);
1535
                  hypot(0.0, 0.0);
1536
                  hypotf(0.0f, 0.0f);
1537
                  hypotl(0.0l, 0.0l);
1538
                  ilogb(0.0);
1539
                  ilogbf(0.0f);
1540
                  ilogbl(0.0l);
1541
                  lgamma(0.0);
1542
                  lgammaf(0.0f);
1543
                  lgammal(0.0l);
1544
                  llrint(0.0);
1545
                  llrintf(0.0f);
1546
                  llrintl(0.0l);
1547
                  llround(0.0);
1548
                  llroundf(0.0f);
1549
                  llroundl(0.0l);
1550
                  log1p(0.0);
1551
                  log1pf(0.0f);
1552
                  log1pl(0.0l);
1553
                  log2(0.0);
1554
                  log2f(0.0f);
1555
                  log2l(0.0l);
1556
                  logb(0.0);
1557
                  logbf(0.0f);
1558
                  logbl(0.0l);
1559
                  lrint(0.0);
1560
                  lrintf(0.0f);
1561
                  lrintl(0.0l);
1562
                  lround(0.0);
1563
                  lroundf(0.0f);
1564
                  lroundl(0.0l);
1565
                  nan(0);
1566
                  nanf(0);
1567
                  nanl(0);
1568
                  nearbyint(0.0);
1569
                  nearbyintf(0.0f);
1570
                  nearbyintl(0.0l);
1571
                  nextafter(0.0, 0.0);
1572
                  nextafterf(0.0f, 0.0f);
1573
                  nextafterl(0.0l, 0.0l);
1574
                  nexttoward(0.0, 0.0);
1575
                  nexttowardf(0.0f, 0.0f);
1576
                  nexttowardl(0.0l, 0.0l);
1577
                  remainder(0.0, 0.0);
1578
                  remainderf(0.0f, 0.0f);
1579
                  remainderl(0.0l, 0.0l);
1580
                  remquo(0.0, 0.0, 0);
1581
                  remquof(0.0f, 0.0f, 0);
1582
                  remquol(0.0l, 0.0l, 0);
1583
                  rint(0.0);
1584
                  rintf(0.0f);
1585
                  rintl(0.0l);
1586
                  round(0.0);
1587
                  roundf(0.0f);
1588
                  roundl(0.0l);
1589
                  scalbln(0.0, 0l);
1590
                  scalblnf(0.0f, 0l);
1591
                  scalblnl(0.0l, 0l);
1592
                  scalbn(0.0, 0);
1593
                  scalbnf(0.0f, 0);
1594
                  scalbnl(0.0l, 0);
1595
                  tgamma(0.0);
1596
                  tgammaf(0.0f);
1597
                  tgammal(0.0l);
1598
                  trunc(0.0);
1599
                  truncf(0.0f);
1600
                  truncl(0.0l);
1601
                 ],[glibcxx_cv_c99_math_tr1=yes], [glibcxx_cv_c99_math_tr1=no])
1602
  ])
1603
  AC_MSG_RESULT($glibcxx_cv_c99_math_tr1)
1604
  if test x"$glibcxx_cv_c99_math_tr1" = x"yes"; then
1605
    AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
1606
              [Define if C99 functions or macros in <math.h> should be imported
1607
              in <tr1/cmath> in namespace std::tr1.])
1608
  fi
1609
 
1610
  # Check for the existence of <inttypes.h> functions (NB: doesn't make
1611
  # sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1612
  ac_c99_inttypes_tr1=no;
1613
  if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1614
    AC_MSG_CHECKING([for ISO C99 support to TR1 in <inttypes.h>])
1615
    AC_TRY_COMPILE([#include <inttypes.h>],
1616
                   [intmax_t i, numer, denom, base;
1617
                    const char* s;
1618
                    char** endptr;
1619
                    intmax_t ret = imaxabs(i);
1620
                    imaxdiv_t dret = imaxdiv(numer, denom);
1621
                    ret = strtoimax(s, endptr, base);
1622
                    uintmax_t uret = strtoumax(s, endptr, base);
1623
                   ],[ac_c99_inttypes_tr1=yes], [ac_c99_inttypes_tr1=no])
1624
  fi
1625
  AC_MSG_RESULT($ac_c99_inttypes_tr1)
1626
  if test x"$ac_c99_inttypes_tr1" = x"yes"; then
1627
    AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_TR1, 1,
1628
              [Define if C99 functions in <inttypes.h> should be imported in
1629
              <tr1/cinttypes> in namespace std::tr1.])
1630
  fi
1631
 
1632
  # Check for the existence of whcar_t <inttypes.h> functions (NB: doesn't
1633
  # make sense if the glibcxx_cv_c99_stdint_tr1 check fails, per C99, 7.8/1).
1634
  ac_c99_inttypes_wchar_t_tr1=no;
1635
  if test x"$glibcxx_cv_c99_stdint_tr1" = x"yes"; then
1636
    AC_MSG_CHECKING([for wchar_t ISO C99 support to TR1 in <inttypes.h>])
1637
    AC_TRY_COMPILE([#include <inttypes.h>],
1638
                   [intmax_t base;
1639
                    const wchar_t* s;
1640
                    wchar_t** endptr;
1641
                    intmax_t ret = wcstoimax(s, endptr, base);
1642
                    uintmax_t uret = wcstoumax(s, endptr, base);
1643
                   ],[ac_c99_inttypes_wchar_t_tr1=yes],
1644
                     [ac_c99_inttypes_wchar_t_tr1=no])
1645
  fi
1646
  AC_MSG_RESULT($ac_c99_inttypes_wchar_t_tr1)
1647
  if test x"$ac_c99_inttypes_wchar_t_tr1" = x"yes"; then
1648
    AC_DEFINE(_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1, 1,
1649
              [Define if wchar_t C99 functions in <inttypes.h> should be
1650
              imported in <tr1/cinttypes> in namespace std::tr1.])
1651
  fi
1652
 
1653
  # Check for the existence of the <stdbool.h> header.
1654
  AC_CHECK_HEADERS(stdbool.h)
1655
 
1656
  # Check for the existence of the <stdalign.h> header.
1657
  AC_CHECK_HEADERS(stdalign.h)
1658
 
1659
  CXXFLAGS="$ac_save_CXXFLAGS"
1660
  AC_LANG_RESTORE
1661
])
1662
 
1663
dnl
1664
dnl Check whether "/dev/random" and "/dev/urandom" are available for the
1665
dnl random_device of "TR1" (Chapter 5.1, "Random number generation").
1666
dnl
1667
AC_DEFUN([GLIBCXX_CHECK_RANDOM_TR1], [
1668
 
1669
  AC_MSG_CHECKING([for "/dev/random" and "/dev/urandom" for TR1 random_device])
1670
  AC_CACHE_VAL(glibcxx_cv_random_tr1, [
1671
    if test -r /dev/random && test -r /dev/urandom; then
1672
      glibcxx_cv_random_tr1=yes;
1673
    else
1674
      glibcxx_cv_random_tr1=no;
1675
    fi
1676
  ])
1677
  AC_MSG_RESULT($glibcxx_cv_random_tr1)
1678
 
1679
  if test x"$glibcxx_cv_random_tr1" = x"yes"; then
1680
    AC_DEFINE(_GLIBCXX_USE_RANDOM_TR1, 1,
1681
              [Define if /dev/random and /dev/urandom are available for
1682
               the random_device of TR1 (Chapter 5.1).])
1683
  fi
1684
 
1685
])
1686
 
1687
dnl
1688
dnl Compute the EOF, SEEK_CUR, and SEEK_END integer constants.
1689
dnl
1690
AC_DEFUN([GLIBCXX_COMPUTE_STDIO_INTEGER_CONSTANTS], [
1691
 
1692
  AC_CACHE_CHECK([for the value of EOF], glibcxx_cv_stdio_eof, [
1693
  AC_COMPUTE_INT([glibcxx_cv_stdio_eof], [[EOF]],
1694
                 [#include <stdio.h>],
1695
                 [AC_MSG_ERROR([computing EOF failed])])
1696
  ])
1697
  AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_EOF, $glibcxx_cv_stdio_eof,
1698
                     [Define to the value of the EOF integer constant.])
1699
 
1700
  AC_CACHE_CHECK([for the value of SEEK_CUR], glibcxx_cv_stdio_seek_cur, [
1701
  AC_COMPUTE_INT([glibcxx_cv_stdio_seek_cur], [[SEEK_CUR]],
1702
                 [#include <stdio.h>],
1703
                 [AC_MSG_ERROR([computing SEEK_CUR failed])])
1704
  ])
1705
  AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_CUR, $glibcxx_cv_stdio_seek_cur,
1706
                     [Define to the value of the SEEK_CUR integer constant.])
1707
 
1708
  AC_CACHE_CHECK([for the value of SEEK_END], glibcxx_cv_stdio_seek_end, [
1709
  AC_COMPUTE_INT([glibcxx_cv_stdio_seek_end], [[SEEK_END]],
1710
                 [#include <stdio.h>],
1711
                 [AC_MSG_ERROR([computing SEEK_END failed])])
1712
  ])
1713
  AC_DEFINE_UNQUOTED(_GLIBCXX_STDIO_SEEK_END, $glibcxx_cv_stdio_seek_end,
1714
                     [Define to the value of the SEEK_END integer constant.])
1715
])
1716
 
1717
dnl
1718
dnl Check whether required C++ overloads are present in <math.h>.
1719
dnl
1720
 
1721
AC_DEFUN([GLIBCXX_CHECK_MATH_PROTO], [
1722
 
1723
  AC_LANG_SAVE
1724
  AC_LANG_CPLUSPLUS
1725
 
1726
  case "$host" in
1727
    *-*-solaris2.*)
1728
      # Solaris 8 FCS only had an overload for double std::abs(double) in
1729
      # <iso/math_iso.h>.  Patches 111721-04 (SPARC) and 112757-01 (x86)
1730
      # introduced the full set also found from Solaris 9 onwards.
1731
      AC_MSG_CHECKING([for float std::abs(float) overload])
1732
      AC_CACHE_VAL(glibcxx_cv_abs_float, [
1733
        AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1734
          [#include <math.h>
1735
           namespace std {
1736
             inline float abs(float __x)
1737
             {  return __builtin_fabsf(__x); }
1738
           }
1739
        ])],
1740
        [glibcxx_cv_abs_float=no],
1741
        [glibcxx_cv_abs_float=yes]
1742
      )])
1743
 
1744
      # autoheader cannot handle indented templates.
1745
      AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO1],
1746
        [/* Define if all C++ overloads are available in <math.h>.  */
1747
#if __cplusplus >= 199711L
1748
#undef __CORRECT_ISO_CPP_MATH_H_PROTO1
1749
#endif])
1750
      AH_VERBATIM([__CORRECT_ISO_CPP_MATH_H_PROTO2],
1751
        [/* Define if only double std::abs(double) is available in <math.h>.  */
1752
#if __cplusplus >= 199711L
1753
#undef __CORRECT_ISO_CPP_MATH_H_PROTO2
1754
#endif])
1755
 
1756
      if test $glibcxx_cv_abs_float = yes; then
1757
        AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO1)
1758
      else
1759
        AC_DEFINE(__CORRECT_ISO_CPP_MATH_H_PROTO2)
1760
      fi
1761
      AC_MSG_RESULT($glibcxx_cv_abs_float)
1762
      ;;
1763
  esac
1764
 
1765
  AC_LANG_RESTORE
1766
])
1767
 
1768
dnl
1769
dnl Check whether required C++ overloads are present in <stdlib.h>.
1770
dnl
1771
 
1772
AC_DEFUN([GLIBCXX_CHECK_STDLIB_PROTO], [
1773
 
1774
  AC_LANG_SAVE
1775
  AC_LANG_CPLUSPLUS
1776
 
1777
  case "$host" in
1778
    *-*-solaris2.*)
1779
      # Solaris 8 FCS lacked the overloads for long std::abs(long) and
1780
      # ldiv_t std::div(long, long) in <iso/stdlib_iso.h>.  Patches 109607-02
1781
      # (SPARC) and 109608-02 (x86) introduced them.
1782
      AC_MSG_CHECKING([for long std::abs(long) overload])
1783
      AC_CACHE_VAL(glibcxx_cv_abs_long, [
1784
        AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1785
          [#include <stdlib.h>
1786
           namespace std {
1787
             inline long
1788
             abs(long __i) { return labs(__i); }
1789
           }
1790
        ])],
1791
        [glibcxx_cv_abs_long=no],
1792
        [glibcxx_cv_abs_long=yes]
1793
      )])
1794
 
1795
      # autoheader cannot handle indented templates.
1796
      AH_VERBATIM([__CORRECT_ISO_CPP_STDLIB_H_PROTO],
1797
        [/* Define if all C++ overloads are available in <stdlib.h>.  */
1798
#if __cplusplus >= 199711L
1799
#undef __CORRECT_ISO_CPP_STDLIB_H_PROTO
1800
#endif])
1801
      if test $glibcxx_cv_abs_long = yes; then
1802
        AC_DEFINE(__CORRECT_ISO_CPP_STDLIB_H_PROTO, 1)
1803
      fi
1804
      AC_MSG_RESULT($glibcxx_cv_abs_long)
1805
      ;;
1806
  esac
1807
 
1808
  AC_LANG_RESTORE
1809
])
1810
 
1811
dnl
1812
dnl Check whether macros, etc are present for <system_error>
1813
dnl
1814
AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [
1815
 
1816
m4_pushdef([n_syserr], [1])dnl
1817
m4_foreach([syserr], [EOWNERDEAD, ENOTRECOVERABLE, ENOLINK, EPROTO, ENODATA,
1818
                      ENOSR, ENOSTR, ETIME, EBADMSG, ECANCELED,
1819
                      EOVERFLOW, ENOTSUP, EIDRM, ETXTBSY,
1820
                      ECHILD, ENOSPC, EPERM,
1821
                      ETIMEDOUT, EWOULDBLOCK],
1822
[m4_pushdef([SYSERR], m4_toupper(syserr))dnl
1823
AC_MSG_CHECKING([for syserr])
1824
AC_CACHE_VAL([glibcxx_cv_system_error[]n_syserr], [
1825
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]],
1826
                                   [int i = syserr;])],
1827
                  [glibcxx_cv_system_error[]n_syserr=yes],
1828
                  [glibcxx_cv_system_error[]n_syserr=no])
1829
])
1830
AC_MSG_RESULT([$glibcxx_cv_system_error[]n_syserr])
1831
if test x"$glibcxx_cv_system_error[]n_syserr" = x"yes"; then
1832
  AC_DEFINE([HAVE_]SYSERR, 1, [Define if ]syserr[ exists.])
1833
fi
1834
m4_define([n_syserr], m4_incr(n_syserr))dnl
1835
m4_popdef([SYSERR])dnl
1836
])
1837
m4_popdef([n_syserr])dnl
1838
])
1839
 
1840
dnl
1841
dnl Check for what type of C headers to use.
1842
dnl
1843
dnl --enable-cheaders= [does stuff].
1844
dnl --disable-cheaders [does not do anything, really].
1845
dnl  +  Usage:  GLIBCXX_ENABLE_CHEADERS[(DEFAULT)]
1846
dnl       Where DEFAULT is either 'c' or 'c_std' or 'c_global'.
1847
dnl
1848
AC_DEFUN([GLIBCXX_ENABLE_CHEADERS], [
1849
  GLIBCXX_ENABLE(cheaders,$1,[[[=KIND]]],
1850
    [construct "C" headers for g++], [permit c|c_std|c_global])
1851
  AC_MSG_NOTICE("C" header strategy set to $enable_cheaders)
1852
 
1853
  C_INCLUDE_DIR='${glibcxx_srcdir}/include/'$enable_cheaders
1854
 
1855
  # Allow overrides to configure.host here.
1856
  if test $enable_cheaders = c_global; then
1857
     c_compatibility=yes
1858
  fi
1859
 
1860
  AC_SUBST(C_INCLUDE_DIR)
1861
  GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C, test $enable_cheaders = c)
1862
  GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_STD, test $enable_cheaders = c_std)
1863
  GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_C_GLOBAL, test $enable_cheaders = c_global)
1864
  GLIBCXX_CONDITIONAL(GLIBCXX_C_HEADERS_COMPATIBILITY, test $c_compatibility = yes)
1865
])
1866
 
1867
 
1868
dnl
1869
dnl Check for which locale library to use.  The choice is mapped to
1870
dnl a subdirectory of config/locale.
1871
dnl
1872
dnl Default is generic.
1873
dnl
1874
AC_DEFUN([GLIBCXX_ENABLE_CLOCALE], [
1875
  GLIBCXX_ENABLE(clocale,auto,[[[=MODEL]]],
1876
    [use MODEL for target locale package],
1877
    [permit generic|gnu|ieee_1003.1-2001|newlib|yes|no|auto])
1878
 
1879
  # Deal with gettext issues.  Default to not using it (=no) until we detect
1880
  # support for it later.  Let the user turn it off via --e/d, but let that
1881
  # default to on for easier handling.
1882
  USE_NLS=no
1883
  AC_ARG_ENABLE(nls,
1884
    AC_HELP_STRING([--enable-nls],[use Native Language Support (default)]),
1885
    [],
1886
    [enable_nls=yes])
1887
 
1888
  # Either a known package, or "auto"
1889
  if test $enable_clocale = no || test $enable_clocale = yes; then
1890
     enable_clocale=auto
1891
  fi
1892
  enable_clocale_flag=$enable_clocale
1893
 
1894
  # Probe for locale model to use if none specified.
1895
  # Default to "generic".
1896
  if test $enable_clocale_flag = auto; then
1897
    case ${target_os} in
1898
      linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
1899
        enable_clocale_flag=gnu
1900
        ;;
1901
      darwin* | freebsd*)
1902
        enable_clocale_flag=darwin
1903
        ;;
1904
      *)
1905
        if test x"$with_newlib" = x"yes"; then
1906
          enable_clocale_flag=newlib
1907
        else
1908
          enable_clocale_flag=generic
1909
        fi
1910
        ;;
1911
    esac
1912
  fi
1913
 
1914
  # Sanity check model, and test for special functionality.
1915
  if test $enable_clocale_flag = gnu; then
1916
    AC_EGREP_CPP([_GLIBCXX_ok], [
1917
    #include <features.h>
1918
    #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(__UCLIBC__)
1919
      _GLIBCXX_ok
1920
    #endif
1921
    ], enable_clocale_flag=gnu, enable_clocale_flag=generic)
1922
 
1923
    # Set it to scream when it hurts.
1924
    ac_save_CFLAGS="$CFLAGS"
1925
    CFLAGS="-Wimplicit-function-declaration -Werror"
1926
 
1927
    # Use strxfrm_l if available.
1928
    AC_TRY_COMPILE([#define _GNU_SOURCE 1
1929
                    #include <string.h>
1930
                    #include <locale.h>],
1931
                    [char s[128]; __locale_t loc; strxfrm_l(s, "C", 5, loc);],
1932
                    AC_DEFINE(HAVE_STRXFRM_L, 1,
1933
                    [Define if strxfrm_l is available in <string.h>.]),)
1934
 
1935
    # Use strerror_l if available.
1936
    AC_TRY_COMPILE([#define _GNU_SOURCE 1
1937
                    #include <string.h>
1938
                    #include <locale.h>],
1939
                    [__locale_t loc; strerror_l(5, loc);],
1940
                    AC_DEFINE(HAVE_STRERROR_L, 1,
1941
                    [Define if strerror_l is available in <string.h>.]),)
1942
 
1943
    CFLAGS="$ac_save_CFLAGS"
1944
  fi
1945
 
1946
  # Perhaps use strerror_r if available, and strerror_l isn't.
1947
  ac_save_CFLAGS="$CFLAGS"
1948
  CFLAGS="-Wimplicit-function-declaration -Werror"
1949
  AC_TRY_COMPILE([#define _GNU_SOURCE 1
1950
                  #include <string.h>
1951
                  #include <locale.h>],
1952
                  [char s[128]; strerror_r(5, s, 128);],
1953
                  AC_DEFINE(HAVE_STRERROR_R, 1,
1954
                  [Define if strerror_r is available in <string.h>.]),)
1955
  CFLAGS="$ac_save_CFLAGS"
1956
 
1957
  # Set configure bits for specified locale package
1958
  AC_MSG_CHECKING([for C locale to use])
1959
  case ${enable_clocale_flag} in
1960
    generic)
1961
      AC_MSG_RESULT(generic)
1962
 
1963
      CLOCALE_H=config/locale/generic/c_locale.h
1964
      CLOCALE_CC=config/locale/generic/c_locale.cc
1965
      CCODECVT_CC=config/locale/generic/codecvt_members.cc
1966
      CCOLLATE_CC=config/locale/generic/collate_members.cc
1967
      CCTYPE_CC=config/locale/generic/ctype_members.cc
1968
      CMESSAGES_H=config/locale/generic/messages_members.h
1969
      CMESSAGES_CC=config/locale/generic/messages_members.cc
1970
      CMONEY_CC=config/locale/generic/monetary_members.cc
1971
      CNUMERIC_CC=config/locale/generic/numeric_members.cc
1972
      CTIME_H=config/locale/generic/time_members.h
1973
      CTIME_CC=config/locale/generic/time_members.cc
1974
      CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1975
      ;;
1976
    darwin)
1977
      AC_MSG_RESULT(darwin or freebsd)
1978
 
1979
      CLOCALE_H=config/locale/generic/c_locale.h
1980
      CLOCALE_CC=config/locale/generic/c_locale.cc
1981
      CCODECVT_CC=config/locale/generic/codecvt_members.cc
1982
      CCOLLATE_CC=config/locale/generic/collate_members.cc
1983
      CCTYPE_CC=config/locale/darwin/ctype_members.cc
1984
      CMESSAGES_H=config/locale/generic/messages_members.h
1985
      CMESSAGES_CC=config/locale/generic/messages_members.cc
1986
      CMONEY_CC=config/locale/generic/monetary_members.cc
1987
      CNUMERIC_CC=config/locale/generic/numeric_members.cc
1988
      CTIME_H=config/locale/generic/time_members.h
1989
      CTIME_CC=config/locale/generic/time_members.cc
1990
      CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
1991
      ;;
1992
 
1993
    gnu)
1994
      AC_MSG_RESULT(gnu)
1995
 
1996
      # Declare intention to use gettext, and add support for specific
1997
      # languages.
1998
      # For some reason, ALL_LINGUAS has to be before AM-GNU-GETTEXT
1999
      ALL_LINGUAS="de fr"
2000
 
2001
      # Don't call AM-GNU-GETTEXT here. Instead, assume glibc.
2002
      AC_CHECK_PROG(check_msgfmt, msgfmt, yes, no)
2003
      if test x"$check_msgfmt" = x"yes" && test x"$enable_nls" = x"yes"; then
2004
        USE_NLS=yes
2005
      fi
2006
      # Export the build objects.
2007
      for ling in $ALL_LINGUAS; do \
2008
        glibcxx_MOFILES="$glibcxx_MOFILES $ling.mo"; \
2009
        glibcxx_POFILES="$glibcxx_POFILES $ling.po"; \
2010
      done
2011
      AC_SUBST(glibcxx_MOFILES)
2012
      AC_SUBST(glibcxx_POFILES)
2013
 
2014
      CLOCALE_H=config/locale/gnu/c_locale.h
2015
      CLOCALE_CC=config/locale/gnu/c_locale.cc
2016
      CCODECVT_CC=config/locale/gnu/codecvt_members.cc
2017
      CCOLLATE_CC=config/locale/gnu/collate_members.cc
2018
      CCTYPE_CC=config/locale/gnu/ctype_members.cc
2019
      CMESSAGES_H=config/locale/gnu/messages_members.h
2020
      CMESSAGES_CC=config/locale/gnu/messages_members.cc
2021
      CMONEY_CC=config/locale/gnu/monetary_members.cc
2022
      CNUMERIC_CC=config/locale/gnu/numeric_members.cc
2023
      CTIME_H=config/locale/gnu/time_members.h
2024
      CTIME_CC=config/locale/gnu/time_members.cc
2025
      CLOCALE_INTERNAL_H=config/locale/gnu/c++locale_internal.h
2026
      ;;
2027
    ieee_1003.1-2001)
2028
      AC_MSG_RESULT(IEEE 1003.1)
2029
 
2030
      CLOCALE_H=config/locale/ieee_1003.1-2001/c_locale.h
2031
      CLOCALE_CC=config/locale/ieee_1003.1-2001/c_locale.cc
2032
      CCODECVT_CC=config/locale/generic/codecvt_members.cc
2033
      CCOLLATE_CC=config/locale/generic/collate_members.cc
2034
      CCTYPE_CC=config/locale/generic/ctype_members.cc
2035
      CMESSAGES_H=config/locale/ieee_1003.1-2001/messages_members.h
2036
      CMESSAGES_CC=config/locale/ieee_1003.1-2001/messages_members.cc
2037
      CMONEY_CC=config/locale/generic/monetary_members.cc
2038
      CNUMERIC_CC=config/locale/generic/numeric_members.cc
2039
      CTIME_H=config/locale/generic/time_members.h
2040
      CTIME_CC=config/locale/generic/time_members.cc
2041
      CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2042
      ;;
2043
    newlib)
2044
      AC_MSG_RESULT(newlib)
2045
 
2046
      CLOCALE_H=config/locale/generic/c_locale.h
2047
      CLOCALE_CC=config/locale/generic/c_locale.cc
2048
      CCODECVT_CC=config/locale/generic/codecvt_members.cc
2049
      CCOLLATE_CC=config/locale/generic/collate_members.cc
2050
      CCTYPE_CC=config/locale/newlib/ctype_members.cc
2051
      CMESSAGES_H=config/locale/generic/messages_members.h
2052
      CMESSAGES_CC=config/locale/generic/messages_members.cc
2053
      CMONEY_CC=config/locale/generic/monetary_members.cc
2054
      CNUMERIC_CC=config/locale/generic/numeric_members.cc
2055
      CTIME_H=config/locale/generic/time_members.h
2056
      CTIME_CC=config/locale/generic/time_members.cc
2057
      CLOCALE_INTERNAL_H=config/locale/generic/c++locale_internal.h
2058
      ;;
2059
  esac
2060
 
2061
  # This is where the testsuite looks for locale catalogs, using the
2062
  # -DLOCALEDIR define during testsuite compilation.
2063
  glibcxx_localedir=${glibcxx_builddir}/po/share/locale
2064
  AC_SUBST(glibcxx_localedir)
2065
 
2066
  # A standalone libintl (e.g., GNU libintl) may be in use.
2067
  if test $USE_NLS = yes; then
2068
    AC_CHECK_HEADERS([libintl.h], [], USE_NLS=no)
2069
    AC_SEARCH_LIBS(gettext, intl, [], USE_NLS=no)
2070
  fi
2071
  if test $USE_NLS = yes; then
2072
    AC_DEFINE(_GLIBCXX_USE_NLS, 1,
2073
              [Define if NLS translations are to be used.])
2074
  fi
2075
 
2076
  AC_SUBST(USE_NLS)
2077
  AC_SUBST(CLOCALE_H)
2078
  AC_SUBST(CMESSAGES_H)
2079
  AC_SUBST(CCODECVT_CC)
2080
  AC_SUBST(CCOLLATE_CC)
2081
  AC_SUBST(CCTYPE_CC)
2082
  AC_SUBST(CMESSAGES_CC)
2083
  AC_SUBST(CMONEY_CC)
2084
  AC_SUBST(CNUMERIC_CC)
2085
  AC_SUBST(CTIME_H)
2086
  AC_SUBST(CTIME_CC)
2087
  AC_SUBST(CLOCALE_CC)
2088
  AC_SUBST(CLOCALE_INTERNAL_H)
2089
])
2090
 
2091
 
2092
dnl
2093
dnl Check for which std::allocator base class to use.  The choice is
2094
dnl mapped from a subdirectory of include/ext.
2095
dnl
2096
dnl Default is new.
2097
dnl
2098
AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
2099
  AC_MSG_CHECKING([for std::allocator base class])
2100
  GLIBCXX_ENABLE(libstdcxx-allocator,auto,[[[=KIND]]],
2101
    [use KIND for target std::allocator base],
2102
    [permit new|malloc|mt|bitmap|pool|yes|no|auto])
2103
 
2104
  # If they didn't use this option switch, or if they specified --enable
2105
  # with no specific model, we'll have to look for one.  If they
2106
  # specified --disable (???), do likewise.
2107
  if test $enable_libstdcxx_allocator = no ||
2108
     test $enable_libstdcxx_allocator = yes;
2109
  then
2110
     enable_libstdcxx_allocator=auto
2111
  fi
2112
 
2113
  # Either a known package, or "auto". Auto implies the default choice
2114
  # for a particular platform.
2115
  enable_libstdcxx_allocator_flag=$enable_libstdcxx_allocator
2116
 
2117
  # Probe for host-specific support if no specific model is specified.
2118
  # Default to "new".
2119
  if test $enable_libstdcxx_allocator_flag = auto; then
2120
    case ${target_os} in
2121
      linux* | gnu* | kfreebsd*-gnu | knetbsd*-gnu)
2122
        enable_libstdcxx_allocator_flag=new
2123
        ;;
2124
      *)
2125
        enable_libstdcxx_allocator_flag=new
2126
        ;;
2127
    esac
2128
  fi
2129
  AC_MSG_RESULT($enable_libstdcxx_allocator_flag)
2130
 
2131
 
2132
  # Set configure bits for specified locale package
2133
  case ${enable_libstdcxx_allocator_flag} in
2134
    bitmap)
2135
      ALLOCATOR_H=config/allocator/bitmap_allocator_base.h
2136
      ALLOCATOR_NAME=__gnu_cxx::bitmap_allocator
2137
      ;;
2138
    malloc)
2139
      ALLOCATOR_H=config/allocator/malloc_allocator_base.h
2140
      ALLOCATOR_NAME=__gnu_cxx::malloc_allocator
2141
      ;;
2142
    mt)
2143
      ALLOCATOR_H=config/allocator/mt_allocator_base.h
2144
      ALLOCATOR_NAME=__gnu_cxx::__mt_alloc
2145
      ;;
2146
    new)
2147
      ALLOCATOR_H=config/allocator/new_allocator_base.h
2148
      ALLOCATOR_NAME=__gnu_cxx::new_allocator
2149
      ;;
2150
    pool)
2151
      ALLOCATOR_H=config/allocator/pool_allocator_base.h
2152
      ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
2153
      ;;
2154
  esac
2155
 
2156
  AC_SUBST(ALLOCATOR_H)
2157
  AC_SUBST(ALLOCATOR_NAME)
2158
])
2159
 
2160
 
2161
dnl
2162
dnl Check for whether the Boost-derived checks should be turned on.
2163
dnl
2164
dnl --enable-concept-checks turns them on.
2165
dnl --disable-concept-checks leaves them off.
2166
dnl  +  Usage:  GLIBCXX_ENABLE_CONCEPT_CHECKS[(DEFAULT)]
2167
dnl       Where DEFAULT is either `yes' or `no'.
2168
dnl
2169
AC_DEFUN([GLIBCXX_ENABLE_CONCEPT_CHECKS], [
2170
  GLIBCXX_ENABLE(concept-checks,$1,,[use Boost-derived template checks])
2171
  if test $enable_concept_checks = yes; then
2172
    AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1,
2173
              [Define to use concept checking code from the boost libraries.])
2174
  fi
2175
])
2176
 
2177
dnl
2178
dnl Use extern templates.
2179
dnl
2180
dnl --enable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 1
2181
dnl --disable-extern-template defines _GLIBCXX_EXTERN_TEMPLATE to 0
2182
 
2183
dnl  +  Usage:  GLIBCXX_ENABLE_TEMPLATE[(DEFAULT)]
2184
dnl       Where DEFAULT is `yes' or `no'.
2185
dnl
2186
AC_DEFUN([GLIBCXX_ENABLE_EXTERN_TEMPLATE], [
2187
 
2188
  GLIBCXX_ENABLE(extern-template,$1,,[enable extern template])
2189
 
2190
  AC_MSG_CHECKING([for extern template support])
2191
  AC_MSG_RESULT([$enable_extern_template])
2192
 
2193
  GLIBCXX_CONDITIONAL(ENABLE_EXTERN_TEMPLATE, test $enable_extern_template = yes)
2194
])
2195
 
2196
dnl
2197
dnl Check for parallel mode pre-requisites, including OpenMP support.
2198
dnl
2199
dnl  +  Usage:  GLIBCXX_ENABLE_PARALLEL
2200
dnl
2201
AC_DEFUN([GLIBCXX_ENABLE_PARALLEL], [
2202
 
2203
  enable_parallel=no;
2204
 
2205
  # See if configured libgomp/omp.h exists. (libgomp may be in
2206
  # noconfigdirs but not explicitly disabled.)
2207
  if echo " ${TARGET_CONFIGDIRS} " | grep " libgomp " > /dev/null 2>&1 ; then
2208
    enable_parallel=yes;
2209
  else
2210
    AC_MSG_NOTICE([target-libgomp not built])
2211
  fi
2212
 
2213
  AC_MSG_CHECKING([for parallel mode support])
2214
  AC_MSG_RESULT([$enable_parallel])
2215
  GLIBCXX_CONDITIONAL(ENABLE_PARALLEL, test $enable_parallel = yes)
2216
])
2217
 
2218
 
2219
dnl
2220
dnl Check for which I/O library to use:  stdio, or something specific.
2221
dnl
2222
dnl Default is stdio.
2223
dnl
2224
AC_DEFUN([GLIBCXX_ENABLE_CSTDIO], [
2225
  AC_MSG_CHECKING([for underlying I/O to use])
2226
  GLIBCXX_ENABLE(cstdio,stdio,[[[=PACKAGE]]],
2227
    [use target-specific I/O package], [permit stdio])
2228
 
2229
  # Now that libio has been removed, you can have any color you want as long
2230
  # as it's black.  This is one big no-op until other packages are added, but
2231
  # showing the framework never hurts.
2232
  case ${enable_cstdio} in
2233
    stdio)
2234
      CSTDIO_H=config/io/c_io_stdio.h
2235
      BASIC_FILE_H=config/io/basic_file_stdio.h
2236
      BASIC_FILE_CC=config/io/basic_file_stdio.cc
2237
      AC_MSG_RESULT(stdio)
2238
      ;;
2239
  esac
2240
 
2241
  AC_SUBST(CSTDIO_H)
2242
  AC_SUBST(BASIC_FILE_H)
2243
  AC_SUBST(BASIC_FILE_CC)
2244
])
2245
 
2246
 
2247
dnl
2248
dnl Check for "unusual" flags to pass to the compiler while building.
2249
dnl
2250
dnl --enable-cxx-flags='-foo -bar -baz' is a general method for passing
2251
dnl     experimental flags such as -fpch, -fIMI, -Dfloat=char, etc.
2252
dnl --disable-cxx-flags passes nothing.
2253
dnl  +  See http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00131.html
2254
dnl         http://gcc.gnu.org/ml/libstdc++/2000-q2/msg00284.html
2255
dnl         http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00035.html
2256
dnl  +  Usage:  GLIBCXX_ENABLE_CXX_FLAGS(default flags)
2257
dnl       If "default flags" is an empty string, the effect is the same
2258
dnl       as --disable or --enable=no.
2259
dnl
2260
AC_DEFUN([GLIBCXX_ENABLE_CXX_FLAGS], [dnl
2261
  AC_MSG_CHECKING([for extra compiler flags for building])
2262
  GLIBCXX_ENABLE(cxx-flags,$1,[=FLAGS],
2263
    [pass compiler FLAGS when building library],
2264
    [case "x$enable_cxx_flags" in
2265
      xno | x)   enable_cxx_flags= ;;
2266
      x-*)       ;;
2267
      *)         AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2268
     esac])
2269
 
2270
  # Run through flags (either default or command-line) and set anything
2271
  # extra (e.g., #defines) that must accompany particular g++ options.
2272
  if test -n "$enable_cxx_flags"; then
2273
    for f in $enable_cxx_flags; do
2274
      case "$f" in
2275
        -fhonor-std)  ;;
2276
        -*)  ;;
2277
        *)   # and we're trying to pass /what/ exactly?
2278
             AC_MSG_ERROR([compiler flags start with a -]) ;;
2279
      esac
2280
    done
2281
  fi
2282
 
2283
  EXTRA_CXX_FLAGS="$enable_cxx_flags"
2284
  AC_MSG_RESULT($EXTRA_CXX_FLAGS)
2285
  AC_SUBST(EXTRA_CXX_FLAGS)
2286
])
2287
 
2288
 
2289
dnl
2290
dnl Check to see if debugging libraries are to be built.
2291
dnl
2292
dnl --enable-libstdcxx-debug
2293
dnl builds a separate set of debugging libraries in addition to the
2294
dnl normal (shared, static) libstdc++ binaries.
2295
dnl
2296
dnl --disable-libstdcxx-debug
2297
dnl builds only one (non-debug) version of libstdc++.
2298
dnl
2299
dnl --enable-libstdcxx-debug-flags=FLAGS
2300
dnl iff --enable-debug == yes, then use FLAGS to build the debug library.
2301
dnl
2302
dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG[(DEFAULT)]
2303
dnl       Where DEFAULT is either `yes' or `no'.
2304
dnl
2305
AC_DEFUN([GLIBCXX_ENABLE_DEBUG], [
2306
  AC_MSG_CHECKING([for additional debug build])
2307
  GLIBCXX_ENABLE(libstdcxx-debug,$1,,[build extra debug library])
2308
  AC_MSG_RESULT($enable_libstdcxx_debug)
2309
  GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_DEBUG, test $enable_libstdcxx_debug = yes)
2310
])
2311
 
2312
 
2313
dnl
2314
dnl Check for explicit debug flags.
2315
dnl
2316
dnl --enable-libstdcxx-debug-flags='-O1'
2317
dnl is a general method for passing flags to be used when
2318
dnl building debug libraries with --enable-debug.
2319
dnl
2320
dnl --disable-libstdcxx-debug-flags does nothing.
2321
dnl  +  Usage:  GLIBCXX_ENABLE_DEBUG_FLAGS(default flags)
2322
dnl       If "default flags" is an empty string, the effect is the same
2323
dnl       as --disable or --enable=no.
2324
dnl
2325
AC_DEFUN([GLIBCXX_ENABLE_DEBUG_FLAGS], [
2326
  GLIBCXX_ENABLE(libstdcxx-debug-flags,[$1],[=FLAGS],
2327
    [pass compiler FLAGS when building debug library],
2328
    [case "x$enable_libstdcxx_debug_flags" in
2329
      xno | x)    enable_libstdcxx_debug_flags= ;;
2330
      x-*)        ;;
2331
      *)          AC_MSG_ERROR(_g_switch needs compiler flags as arguments) ;;
2332
     esac])
2333
 
2334
  # Option parsed, now set things appropriately
2335
  DEBUG_FLAGS="$enable_libstdcxx_debug_flags"
2336
  AC_SUBST(DEBUG_FLAGS)
2337
 
2338
  AC_MSG_NOTICE([Debug build flags set to $DEBUG_FLAGS])
2339
])
2340
 
2341
 
2342
dnl
2343
dnl Check if the user only wants a freestanding library implementation.
2344
dnl
2345
dnl --disable-hosted-libstdcxx will turn off most of the library build,
2346
dnl installing only the headers required by [17.4.1.3] and the language
2347
dnl support library.  More than that will be built (to keep the Makefiles
2348
dnl conveniently clean), but not installed.
2349
dnl
2350
dnl Sets:
2351
dnl  is_hosted  (yes/no)
2352
dnl
2353
dnl Defines:
2354
dnl  _GLIBCXX_HOSTED   (always defined, either to 1 or 0)
2355
dnl
2356
AC_DEFUN([GLIBCXX_ENABLE_HOSTED], [
2357
  AC_ARG_ENABLE([hosted-libstdcxx],
2358
    AC_HELP_STRING([--disable-hosted-libstdcxx],
2359
                   [only build freestanding C++ runtime support]),,
2360
    [case "$host" in
2361
        arm*-*-symbianelf*)
2362
            enable_hosted_libstdcxx=no
2363
            ;;
2364
        *)
2365
            enable_hosted_libstdcxx=yes
2366
            ;;
2367
     esac])
2368
  if test "$enable_hosted_libstdcxx" = no; then
2369
    AC_MSG_NOTICE([Only freestanding libraries will be built])
2370
    is_hosted=no
2371
    hosted_define=0
2372
    enable_abi_check=no
2373
    enable_libstdcxx_pch=no
2374
  else
2375
    is_hosted=yes
2376
    hosted_define=1
2377
  fi
2378
  GLIBCXX_CONDITIONAL(GLIBCXX_HOSTED, test $is_hosted = yes)
2379
  AC_DEFINE_UNQUOTED(_GLIBCXX_HOSTED, $hosted_define,
2380
    [Define to 1 if a full hosted library is built, or 0 if freestanding.])
2381
])
2382
 
2383
 
2384
dnl
2385
dnl Check for template specializations for the 'long long' type.
2386
dnl The result determines only whether 'long long' I/O is enabled; things
2387
dnl like numeric_limits<> specializations are always available.
2388
dnl
2389
dnl --enable-long-long defines _GLIBCXX_USE_LONG_LONG
2390
dnl --disable-long-long leaves _GLIBCXX_USE_LONG_LONG undefined
2391
dnl  +  Usage:  GLIBCXX_ENABLE_LONG_LONG[(DEFAULT)]
2392
dnl       Where DEFAULT is either `yes' or `no'.
2393
dnl
2394
AC_DEFUN([GLIBCXX_ENABLE_LONG_LONG], [
2395
  GLIBCXX_ENABLE(long-long,$1,,[enable template specializations for 'long long'])
2396
  if test $enable_long_long = yes; then
2397
    AC_DEFINE(_GLIBCXX_USE_LONG_LONG, 1,
2398
              [Define if code specialized for long long should be used.])
2399
  fi
2400
  AC_MSG_CHECKING([for enabled long long specializations])
2401
  AC_MSG_RESULT([$enable_long_long])
2402
])
2403
 
2404
 
2405
dnl
2406
dnl Check for decimal floating point.
2407
dnl See:
2408
dnl http://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html#Decimal-Float
2409
dnl
2410
dnl This checks to see if the host supports decimal floating point types.
2411
dnl
2412
dnl Defines:
2413
dnl  _GLIBCXX_USE_DECIMAL_FLOAT
2414
dnl
2415
AC_DEFUN([GLIBCXX_ENABLE_DECIMAL_FLOAT], [
2416
 
2417
  # Fake what AC_TRY_COMPILE does, without linking as this is
2418
  # unnecessary for this test.
2419
 
2420
    cat > conftest.$ac_ext << EOF
2421
[#]line __oline__ "configure"
2422
int main()
2423
{
2424
  _Decimal32 d1;
2425
  _Decimal64 d2;
2426
  _Decimal128 d3;
2427
  return 0;
2428
}
2429
EOF
2430
 
2431
    AC_MSG_CHECKING([for ISO/IEC TR 24733 ])
2432
    if AC_TRY_EVAL(ac_compile); then
2433
      AC_DEFINE(_GLIBCXX_USE_DECIMAL_FLOAT, 1,
2434
      [Define if ISO/IEC TR 24733 decimal floating point types are supported on this host.])
2435
      enable_dfp=yes
2436
    else
2437
      enable_dfp=no
2438
    fi
2439
    AC_MSG_RESULT($enable_dfp)
2440
    rm -f conftest*
2441
])
2442
 
2443
dnl
2444
dnl Check for GNU 128-bit integer and floating point types.
2445
dnl
2446
dnl Note: also checks that the types aren't standard types.
2447
dnl
2448
dnl Defines:
2449
dnl  _GLIBCXX_USE_INT128
2450
dnl  _GLIBCXX_USE_FLOAT128
2451
dnl
2452
AC_DEFUN([GLIBCXX_ENABLE_INT128_FLOAT128], [
2453
 
2454
  AC_LANG_SAVE
2455
  AC_LANG_CPLUSPLUS
2456
 
2457
  # Fake what AC_TRY_COMPILE does, without linking as this is
2458
  # unnecessary for this test.
2459
 
2460
    cat > conftest.$ac_ext << EOF
2461
[#]line __oline__ "configure"
2462
template<typename T1, typename T2>
2463
  struct same
2464
  { typedef T2 type; };
2465
 
2466
template<typename T>
2467
  struct same<T, T>;
2468
 
2469
int main()
2470
{
2471
  typename same<long, __int128>::type                i1;
2472
  typename same<long long, __int128>::type           i2;
2473
}
2474
EOF
2475
 
2476
    AC_MSG_CHECKING([for __int128])
2477
    if AC_TRY_EVAL(ac_compile); then
2478
      AC_DEFINE(_GLIBCXX_USE_INT128, 1,
2479
      [Define if __int128 is supported on this host.])
2480
      enable_int128=yes
2481
    else
2482
      enable_int128=no
2483
    fi
2484
    AC_MSG_RESULT($enable_int128)
2485
    rm -f conftest*
2486
 
2487
    cat > conftest.$ac_ext << EOF
2488
[#]line __oline__ "configure"
2489
template<typename T1, typename T2>
2490
  struct same
2491
  { typedef T2 type; };
2492
 
2493
template<typename T>
2494
  struct same<T, T>;
2495
 
2496
int main()
2497
{
2498
  typename same<double, __float128>::type      f1;
2499
  typename same<long double, __float128>::type f2;
2500
}
2501
EOF
2502
 
2503
    AC_MSG_CHECKING([for __float128])
2504
    if AC_TRY_EVAL(ac_compile); then
2505
      AC_DEFINE(_GLIBCXX_USE_FLOAT128, 1,
2506
      [Define if __float128 is supported on this host.])
2507
      enable_float128=yes
2508
    else
2509
      enable_float128=no
2510
    fi
2511
    AC_MSG_RESULT($enable_float128)
2512
    rm -f conftest*
2513
 
2514
  AC_LANG_RESTORE
2515
])
2516
 
2517
dnl
2518
dnl Check for template specializations for the 'wchar_t' type.
2519
dnl
2520
dnl --enable-wchar_t defines _GLIBCXX_USE_WCHAR_T
2521
dnl --disable-wchar_t leaves _GLIBCXX_USE_WCHAR_T undefined
2522
dnl  +  Usage:  GLIBCXX_ENABLE_WCHAR_T[(DEFAULT)]
2523
dnl       Where DEFAULT is either `yes' or `no'.
2524
dnl
2525
dnl Necessary support must also be present.
2526
dnl
2527
AC_DEFUN([GLIBCXX_ENABLE_WCHAR_T], [
2528
  GLIBCXX_ENABLE(wchar_t,$1,,[enable template specializations for 'wchar_t'])
2529
 
2530
  # Test wchar.h for mbstate_t, which is needed for char_traits and fpos.
2531
  AC_CHECK_HEADERS(wchar.h, ac_has_wchar_h=yes, ac_has_wchar_h=no)
2532
  AC_MSG_CHECKING([for mbstate_t])
2533
  AC_TRY_COMPILE([#include <wchar.h>],
2534
  [mbstate_t teststate;],
2535
  have_mbstate_t=yes, have_mbstate_t=no)
2536
  AC_MSG_RESULT($have_mbstate_t)
2537
  if test x"$have_mbstate_t" = xyes; then
2538
    AC_DEFINE(HAVE_MBSTATE_T,1,[Define if mbstate_t exists in wchar.h.])
2539
  fi
2540
 
2541
  # Test it always, for use in GLIBCXX_ENABLE_C99, together with
2542
  # ac_has_wchar_h.
2543
  AC_CHECK_HEADERS(wctype.h, ac_has_wctype_h=yes, ac_has_wctype_h=no)
2544
 
2545
  if test x"$enable_wchar_t" = x"yes"; then
2546
 
2547
    AC_LANG_SAVE
2548
    AC_LANG_CPLUSPLUS
2549
 
2550
    if test x"$ac_has_wchar_h" = xyes &&
2551
       test x"$ac_has_wctype_h" = xyes; then
2552
      AC_TRY_COMPILE([#include <wchar.h>
2553
                      #include <stddef.h>
2554
                      wint_t i;
2555
                      long l = WEOF;
2556
                      long j = WCHAR_MIN;
2557
                      long k = WCHAR_MAX;
2558
                      namespace test
2559
                      {
2560
                        using ::btowc;
2561
                        using ::fgetwc;
2562
                        using ::fgetws;
2563
                        using ::fputwc;
2564
                        using ::fputws;
2565
                        using ::fwide;
2566
                        using ::fwprintf;
2567
                        using ::fwscanf;
2568
                        using ::getwc;
2569
                        using ::getwchar;
2570
                        using ::mbrlen;
2571
                        using ::mbrtowc;
2572
                        using ::mbsinit;
2573
                        using ::mbsrtowcs;
2574
                        using ::putwc;
2575
                        using ::putwchar;
2576
                        using ::swprintf;
2577
                        using ::swscanf;
2578
                        using ::ungetwc;
2579
                        using ::vfwprintf;
2580
                        using ::vswprintf;
2581
                        using ::vwprintf;
2582
                        using ::wcrtomb;
2583
                        using ::wcscat;
2584
                        using ::wcschr;
2585
                        using ::wcscmp;
2586
                        using ::wcscoll;
2587
                        using ::wcscpy;
2588
                        using ::wcscspn;
2589
                        using ::wcsftime;
2590
                        using ::wcslen;
2591
                        using ::wcsncat;
2592
                        using ::wcsncmp;
2593
                        using ::wcsncpy;
2594
                        using ::wcspbrk;
2595
                        using ::wcsrchr;
2596
                        using ::wcsrtombs;
2597
                        using ::wcsspn;
2598
                        using ::wcsstr;
2599
                        using ::wcstod;
2600
                        using ::wcstok;
2601
                        using ::wcstol;
2602
                        using ::wcstoul;
2603
                        using ::wcsxfrm;
2604
                        using ::wctob;
2605
                        using ::wmemchr;
2606
                        using ::wmemcmp;
2607
                        using ::wmemcpy;
2608
                        using ::wmemmove;
2609
                        using ::wmemset;
2610
                        using ::wprintf;
2611
                        using ::wscanf;
2612
                      }
2613
                     ],[],[], [enable_wchar_t=no])
2614
    else
2615
      enable_wchar_t=no
2616
    fi
2617
 
2618
    AC_LANG_RESTORE
2619
  fi
2620
 
2621
  if test x"$enable_wchar_t" = x"yes"; then
2622
    AC_DEFINE(_GLIBCXX_USE_WCHAR_T, 1,
2623
              [Define if code specialized for wchar_t should be used.])
2624
  fi
2625
 
2626
  AC_MSG_CHECKING([for enabled wchar_t specializations])
2627
  AC_MSG_RESULT([$enable_wchar_t])
2628
])
2629
 
2630
 
2631
dnl
2632
dnl Check to see if building and using a C++ precompiled header can be done.
2633
dnl
2634
dnl --enable-libstdcxx-pch=yes
2635
dnl default, this shows intent to use stdc++.h.gch If it looks like it
2636
dnl may work, after some light-hearted attempts to puzzle out compiler
2637
dnl support, flip bits on in include/Makefile.am
2638
dnl
2639
dnl --disable-libstdcxx-pch
2640
dnl turns off attempts to use or build stdc++.h.gch.
2641
dnl
2642
dnl Substs:
2643
dnl  glibcxx_PCHFLAGS
2644
dnl
2645
AC_DEFUN([GLIBCXX_ENABLE_PCH], [
2646
  GLIBCXX_ENABLE(libstdcxx-pch,$1,,[build pre-compiled libstdc++ headers])
2647
  if test $enable_libstdcxx_pch = yes; then
2648
    AC_CACHE_CHECK([for compiler with PCH support],
2649
      [glibcxx_cv_prog_CXX_pch],
2650
      [ac_save_CXXFLAGS="$CXXFLAGS"
2651
       CXXFLAGS="$CXXFLAGS -Werror -Winvalid-pch -Wno-deprecated"
2652
       AC_LANG_SAVE
2653
       AC_LANG_CPLUSPLUS
2654
       echo '#include <math.h>' > conftest.h
2655
       if $CXX $CXXFLAGS $CPPFLAGS -x c++-header conftest.h \
2656
                          -o conftest.h.gch 1>&5 2>&1 &&
2657
                echo '#error "pch failed"' > conftest.h &&
2658
          echo '#include "conftest.h"' > conftest.cc &&
2659
               $CXX -c $CXXFLAGS $CPPFLAGS conftest.cc 1>&5 2>&1 ;
2660
       then
2661
         glibcxx_cv_prog_CXX_pch=yes
2662
       else
2663
         glibcxx_cv_prog_CXX_pch=no
2664
       fi
2665
       rm -f conftest*
2666
       CXXFLAGS=$ac_save_CXXFLAGS
2667
       AC_LANG_RESTORE
2668
      ])
2669
    enable_libstdcxx_pch=$glibcxx_cv_prog_CXX_pch
2670
  fi
2671
 
2672
  AC_MSG_CHECKING([for enabled PCH])
2673
  AC_MSG_RESULT([$enable_libstdcxx_pch])
2674
 
2675
  GLIBCXX_CONDITIONAL(GLIBCXX_BUILD_PCH, test $enable_libstdcxx_pch = yes)
2676
  if test $enable_libstdcxx_pch = yes; then
2677
    glibcxx_PCHFLAGS="-include bits/stdc++.h"
2678
  else
2679
    glibcxx_PCHFLAGS=""
2680
  fi
2681
  AC_SUBST(glibcxx_PCHFLAGS)
2682
])
2683
 
2684
 
2685
dnl
2686
dnl Check for atomic builtins.
2687
dnl See:
2688
dnl http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
2689
dnl
2690
dnl This checks to see if the host supports the compiler-generated
2691
dnl builtins for atomic operations for various integral sizes. Note, this
2692
dnl is intended to be an all-or-nothing switch, so all the atomic operations
2693
dnl that are used should be checked.
2694
dnl
2695
dnl Note:
2696
dnl libgomp and libgfortran use a link test, see CHECK_SYNC_FETCH_AND_ADD.
2697
dnl
2698
AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
2699
  AC_LANG_SAVE
2700
  AC_LANG_CPLUSPLUS
2701
  old_CXXFLAGS="$CXXFLAGS"
2702
 
2703
  # Do link tests if possible, instead asm tests, limited to some platforms
2704
  # see discussion in PR target/40134, PR libstdc++/40133 and the thread
2705
  # starting at http://gcc.gnu.org/ml/gcc-patches/2009-07/msg00322.html
2706
  atomic_builtins_link_tests=no
2707
  if test x$gcc_no_link != xyes; then
2708
    # Can do link tests. Limit to some tested platforms
2709
    case "$host" in
2710
      *-*-linux* | *-*-uclinux* | *-*-kfreebsd*-gnu | *-*-gnu*)
2711
        atomic_builtins_link_tests=yes
2712
        ;;
2713
    esac
2714
  fi
2715
 
2716
  if test x$atomic_builtins_link_tests = xyes; then
2717
 
2718
  # Do link tests.
2719
 
2720
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
2721
 
2722
  AC_MSG_CHECKING([for atomic builtins for bool])
2723
  AC_CACHE_VAL(glibcxx_cv_atomic_bool, [
2724
    AC_TRY_LINK(
2725
      [ ],
2726
      [typedef bool atomic_type;
2727
       atomic_type c1;
2728
       atomic_type c2;
2729
       atomic_type c3(0);
2730
       __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2731
       __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2732
                                   __ATOMIC_RELAXED);
2733
       __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2734
       __atomic_load_n(&c1, __ATOMIC_RELAXED);
2735
      ],
2736
      [glibcxx_cv_atomic_bool=yes],
2737
      [glibcxx_cv_atomic_bool=no])
2738
  ])
2739
  AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2740
 
2741
  AC_MSG_CHECKING([for atomic builtins for short])
2742
  AC_CACHE_VAL(glibcxx_cv_atomic_short, [
2743
    AC_TRY_LINK(
2744
      [ ],
2745
      [typedef short atomic_type;
2746
       atomic_type c1;
2747
       atomic_type c2;
2748
       atomic_type c3(0);
2749
       __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2750
       __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2751
                                   __ATOMIC_RELAXED);
2752
       __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2753
       __atomic_load_n(&c1, __ATOMIC_RELAXED);
2754
      ],
2755
      [glibcxx_cv_atomic_short=yes],
2756
      [glibcxx_cv_atomic_short=no])
2757
  ])
2758
  AC_MSG_RESULT($glibcxx_cv_atomic_short)
2759
 
2760
  AC_MSG_CHECKING([for atomic builtins for int])
2761
  AC_CACHE_VAL(glibcxx_cv_atomic_int, [
2762
    AC_TRY_LINK(
2763
      [ ],
2764
      [typedef int atomic_type;
2765
       atomic_type c1;
2766
       atomic_type c2;
2767
       atomic_type c3(0);
2768
       __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2769
       __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2770
                                   __ATOMIC_RELAXED);
2771
       __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2772
       __atomic_load_n(&c1, __ATOMIC_RELAXED);
2773
      ],
2774
      [glibcxx_cv_atomic_int=yes],
2775
      [glibcxx_cv_atomic_int=no])
2776
  ])
2777
  AC_MSG_RESULT($glibcxx_cv_atomic_int)
2778
 
2779
  AC_MSG_CHECKING([for atomic builtins for long long])
2780
  AC_CACHE_VAL(glibcxx_cv_atomic_long_long, [
2781
    AC_TRY_LINK(
2782
      [ ],
2783
      [typedef long long atomic_type;
2784
       atomic_type c1;
2785
       atomic_type c2;
2786
       atomic_type c3(0);
2787
       __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2788
       __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2789
                                   __ATOMIC_RELAXED);
2790
       __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2791
       __atomic_load_n(&c1, __ATOMIC_RELAXED);
2792
      ],
2793
      [glibcxx_cv_atomic_long_long=yes],
2794
      [glibcxx_cv_atomic_long_long=no])
2795
  ])
2796
  AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2797
 
2798
  else
2799
 
2800
  # Do asm tests.
2801
 
2802
  # Compile unoptimized.
2803
  CXXFLAGS='-O0 -S'
2804
 
2805
  # Fake what AC_TRY_COMPILE does.
2806
 
2807
    cat > conftest.$ac_ext << EOF
2808
[#]line __oline__ "configure"
2809
int main()
2810
{
2811
  typedef bool atomic_type;
2812
  atomic_type c1;
2813
  atomic_type c2;
2814
  atomic_type c3(0);
2815
  __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2816
  __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2817
                              __ATOMIC_RELAXED);
2818
  __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2819
  __atomic_load_n(&c1, __ATOMIC_RELAXED);
2820
 
2821
  return 0;
2822
}
2823
EOF
2824
 
2825
    AC_MSG_CHECKING([for atomic builtins for bool])
2826
    if AC_TRY_EVAL(ac_compile); then
2827
      if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2828
        glibcxx_cv_atomic_bool=no
2829
      else
2830
        glibcxx_cv_atomic_bool=yes
2831
      fi
2832
    fi
2833
    AC_MSG_RESULT($glibcxx_cv_atomic_bool)
2834
    rm -f conftest*
2835
 
2836
    cat > conftest.$ac_ext << EOF
2837
[#]line __oline__ "configure"
2838
int main()
2839
{
2840
  typedef short atomic_type;
2841
  atomic_type c1;
2842
  atomic_type c2;
2843
  atomic_type c3(0);
2844
  __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2845
  __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2846
                              __ATOMIC_RELAXED);
2847
  __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2848
  __atomic_load_n(&c1, __ATOMIC_RELAXED);
2849
 
2850
  return 0;
2851
}
2852
EOF
2853
 
2854
    AC_MSG_CHECKING([for atomic builtins for short])
2855
    if AC_TRY_EVAL(ac_compile); then
2856
      if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2857
        glibcxx_cv_atomic_short=no
2858
      else
2859
        glibcxx_cv_atomic_short=yes
2860
      fi
2861
    fi
2862
    AC_MSG_RESULT($glibcxx_cv_atomic_short)
2863
    rm -f conftest*
2864
 
2865
    cat > conftest.$ac_ext << EOF
2866
[#]line __oline__ "configure"
2867
int main()
2868
{
2869
  // NB: _Atomic_word not necessarily int.
2870
  typedef int atomic_type;
2871
  atomic_type c1;
2872
  atomic_type c2;
2873
  atomic_type c3(0);
2874
  __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2875
  __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2876
                              __ATOMIC_RELAXED);
2877
  __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2878
  __atomic_load_n(&c1, __ATOMIC_RELAXED);
2879
 
2880
  return 0;
2881
}
2882
EOF
2883
 
2884
    AC_MSG_CHECKING([for atomic builtins for int])
2885
    if AC_TRY_EVAL(ac_compile); then
2886
      if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2887
        glibcxx_cv_atomic_int=no
2888
      else
2889
        glibcxx_cv_atomic_int=yes
2890
      fi
2891
    fi
2892
    AC_MSG_RESULT($glibcxx_cv_atomic_int)
2893
    rm -f conftest*
2894
 
2895
    cat > conftest.$ac_ext << EOF
2896
[#]line __oline__ "configure"
2897
int main()
2898
{
2899
  typedef long long atomic_type;
2900
  atomic_type c1;
2901
  atomic_type c2;
2902
  atomic_type c3(0);
2903
  __atomic_fetch_add(&c1, c2, __ATOMIC_RELAXED);
2904
  __atomic_compare_exchange_n(&c1, &c2, c3, true, __ATOMIC_ACQ_REL,
2905
                              __ATOMIC_RELAXED);
2906
  __atomic_test_and_set(&c1, __ATOMIC_RELAXED);
2907
  __atomic_load_n(&c1, __ATOMIC_RELAXED);
2908
 
2909
  return 0;
2910
}
2911
EOF
2912
 
2913
    AC_MSG_CHECKING([for atomic builtins for long long])
2914
    if AC_TRY_EVAL(ac_compile); then
2915
      if grep __atomic_ conftest.s >/dev/null 2>&1 ; then
2916
        glibcxx_cv_atomic_long_long=no
2917
      else
2918
        glibcxx_cv_atomic_long_long=yes
2919
      fi
2920
    fi
2921
    AC_MSG_RESULT($glibcxx_cv_atomic_long_long)
2922
    rm -f conftest*
2923
 
2924
  fi
2925
 
2926
  CXXFLAGS="$old_CXXFLAGS"
2927
  AC_LANG_RESTORE
2928
 
2929
  # Set atomicity_dir to builtins if all of above tests pass.
2930
  if test $glibcxx_cv_atomic_bool = yes \
2931
     && test $glibcxx_cv_atomic_short = yes \
2932
     && test $glibcxx_cv_atomic_int = yes \
2933
     && test $glibcxx_cv_atomic_long_long = yes ; then
2934
    AC_DEFINE(_GLIBCXX_ATOMIC_BUILTINS, 1,
2935
    [Define if the compiler supports C++11 atomics.])
2936
    atomicity_dir=cpu/generic/atomicity_builtins
2937
  fi
2938
 
2939
  # If still generic, set to mutex.
2940
  if test $atomicity_dir = "cpu/generic" ; then
2941
    atomicity_dir=cpu/generic/atomicity_mutex
2942
    AC_MSG_WARN([No native atomic operations are provided for this platform.])
2943
      if test "x$target_thread_file" = xsingle; then
2944
        AC_MSG_WARN([They cannot be faked when thread support is disabled.])
2945
        AC_MSG_WARN([Thread-safety of certain classes is not guaranteed.])
2946
      else
2947
        AC_MSG_WARN([They will be faked using a mutex.])
2948
        AC_MSG_WARN([Performance of certain classes will degrade as a result.])
2949
      fi
2950
  fi
2951
 
2952
])
2953
 
2954
 
2955
dnl
2956
dnl Check for exception handling support.  If an explicit enable/disable
2957
dnl sjlj exceptions is given, we don't have to detect.  Otherwise the
2958
dnl target may or may not support call frame exceptions.
2959
dnl
2960
dnl --enable-sjlj-exceptions forces the use of builtin setjmp.
2961
dnl --disable-sjlj-exceptions forces the use of call frame unwinding.
2962
dnl Neither one forces an attempt at detection.
2963
dnl
2964
dnl Defines:
2965
dnl  _GLIBCXX_SJLJ_EXCEPTIONS if the compiler is configured for it
2966
dnl
2967
AC_DEFUN([GLIBCXX_ENABLE_SJLJ_EXCEPTIONS], [
2968
  AC_MSG_CHECKING([for exception model to use])
2969
  AC_LANG_SAVE
2970
  AC_LANG_CPLUSPLUS
2971
  GLIBCXX_ENABLE(sjlj-exceptions,auto,,
2972
    [force use of builtin_setjmp for exceptions],
2973
    [permit yes|no|auto])
2974
 
2975
  if test $enable_sjlj_exceptions = auto; then
2976
    # Botheration.  Now we've got to detect the exception model.  Link tests
2977
    # against libgcc.a are problematic since we've not been given proper -L
2978
    # bits for single-tree newlib and libgloss.
2979
    #
2980
    # Fake what AC_TRY_COMPILE does.  XXX Look at redoing this new-style.
2981
    cat > conftest.$ac_ext << EOF
2982
[#]line __oline__ "configure"
2983
struct S { ~S(); };
2984
void bar();
2985
void foo()
2986
{
2987
  S s;
2988
  bar();
2989
}
2990
EOF
2991
    old_CXXFLAGS="$CXXFLAGS"
2992
    CXXFLAGS=-S
2993
    if AC_TRY_EVAL(ac_compile); then
2994
      if grep _Unwind_SjLj_Resume conftest.s >/dev/null 2>&1 ; then
2995
        enable_sjlj_exceptions=yes
2996
      elif grep _Unwind_Resume conftest.s >/dev/null 2>&1 ; then
2997
        enable_sjlj_exceptions=no
2998
      elif grep __cxa_end_cleanup conftest.s >/dev/null 2>&1 ; then
2999
        enable_sjlj_exceptions=no
3000
      fi
3001
    fi
3002
    CXXFLAGS="$old_CXXFLAGS"
3003
    rm -f conftest*
3004
  fi
3005
 
3006
  # This is a tad weird, for hysterical raisins.  We have to map
3007
  # enable/disable to two different models.
3008
  case $enable_sjlj_exceptions in
3009
    yes)
3010
      AC_DEFINE(_GLIBCXX_SJLJ_EXCEPTIONS, 1,
3011
        [Define if the compiler is configured for setjmp/longjmp exceptions.])
3012
      ac_exception_model_name=sjlj
3013
      ;;
3014
    no)
3015
      ac_exception_model_name="call frame"
3016
      ;;
3017
    *)
3018
      AC_MSG_ERROR([unable to detect exception model])
3019
      ;;
3020
  esac
3021
 AC_LANG_RESTORE
3022
 AC_MSG_RESULT($ac_exception_model_name)
3023
])
3024
 
3025
 
3026
dnl
3027
dnl Allow visibility attributes to be used on namespaces, objects, etc.
3028
dnl
3029
dnl --enable-libstdcxx-visibility enables attempt to use visibility attributes.
3030
dnl --disable-libstdcxx-visibility turns off all use of visibility attributes.
3031
dnl  +  Usage:  GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY[(DEFAULT)]
3032
dnl       Where DEFAULT is 'yes'.
3033
dnl
3034
AC_DEFUN([GLIBCXX_ENABLE_LIBSTDCXX_VISIBILITY], [
3035
GLIBCXX_ENABLE(libstdcxx-visibility,$1,,[enables visibility safe usage])
3036
 
3037
if test x$enable_libstdcxx_visibility = xyes ; then
3038
  dnl all hail libgfortran
3039
  dnl Check whether the target supports hidden visibility.
3040
  AC_CACHE_CHECK([whether the target supports hidden visibility],
3041
                 glibcxx_cv_have_attribute_visibility, [
3042
  save_CFLAGS="$CFLAGS"
3043
  CFLAGS="$CFLAGS -Werror"
3044
  AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
3045
                 [], glibcxx_cv_have_attribute_visibility=yes,
3046
                 glibcxx_cv_have_attribute_visibility=no)
3047
  CFLAGS="$save_CFLAGS"])
3048
  if test $glibcxx_cv_have_attribute_visibility = no; then
3049
    enable_libstdcxx_visibility=no
3050
  fi
3051
fi
3052
 
3053
GLIBCXX_CONDITIONAL(ENABLE_VISIBILITY, test $enable_libstdcxx_visibility = yes)
3054
AC_MSG_NOTICE([visibility supported: $enable_libstdcxx_visibility])
3055
])
3056
 
3057
 
3058
dnl
3059
dnl Add version tags to symbols in shared library (or not), additionally
3060
dnl marking other symbols as private/local (or not).
3061
dnl
3062
dnl Sets libtool_VERSION, and determines shared library SONAME.
3063
dnl
3064
dnl  This depends on GLIBCXX CHECK_LINKER_FEATURES, but without it assumes no.
3065
dnl
3066
dnl --enable-symvers=style adds a version script to the linker call when
3067
dnl       creating the shared library.  The choice of version script is
3068
dnl       controlled by 'style'.
3069
dnl --disable-symvers does not.
3070
dnl
3071
dnl  +  Usage:  GLIBCXX_ENABLE_SYMVERS[(DEFAULT)]
3072
dnl       Where DEFAULT is either 'yes' or 'no'.  Passing `yes' tries to
3073
dnl       choose a default style based on linker characteristics.  Passing
3074
dnl       'no' disables versioning.
3075
dnl
3076
AC_DEFUN([GLIBCXX_ENABLE_SYMVERS], [
3077
 
3078
GLIBCXX_ENABLE(symvers,$1,[[[=STYLE]]],
3079
  [enables symbol versioning of the shared library],
3080
  [permit yes|no|gnu|gnu-versioned-namespace|darwin|darwin-export|sun])
3081
 
3082
# If we never went through the GLIBCXX_CHECK_LINKER_FEATURES macro, then we
3083
# don't know enough about $LD to do tricks...
3084
AC_REQUIRE([GLIBCXX_CHECK_LINKER_FEATURES])
3085
# Sun style symbol versions needs GNU c++filt for make_sunver.pl to work
3086
# with extern "C++" in version scripts.
3087
AC_REQUIRE([GCC_PROG_GNU_CXXFILT])
3088
 
3089
# Turn a 'yes' into a suitable default.
3090
if test x$enable_symvers = xyes ; then
3091
  if test $enable_shared = no || test "x$LD" = x || test x$gcc_no_link = xyes; then
3092
    enable_symvers=no
3093
  else
3094
    if test $with_gnu_ld = yes ; then
3095
      case ${target_os} in
3096
        hpux*)
3097
          enable_symvers=no ;;
3098
        *)
3099
          enable_symvers=gnu ;;
3100
      esac
3101
    else
3102
      case ${target_os} in
3103
        darwin*)
3104
          enable_symvers=darwin ;;
3105
        # Sun symbol versioning exists since Solaris 2.5.
3106
        solaris2.[[5-9]]* | solaris2.1[[0-9]]*)
3107
          # make_sunver.pl needs GNU c++filt to support extern "C++" in
3108
          # version scripts, so disable symbol versioning if none can be
3109
          # found.
3110
          if test -z "$ac_cv_path_CXXFILT"; then
3111
            AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3112
            AC_MSG_WARN([=== no GNU c++filt could  be found.])
3113
            AC_MSG_WARN([=== Symbol versioning will be disabled.])
3114
            enable_symvers=no
3115
          else
3116
            enable_symvers=sun
3117
          fi
3118
          ;;
3119
        *)
3120
          enable_symvers=no ;;
3121
      esac
3122
    fi
3123
  fi
3124
fi
3125
 
3126
# Check to see if 'darwin' or 'darwin-export' can win.
3127
if test x$enable_symvers = xdarwin-export ; then
3128
    enable_symvers=darwin
3129
fi
3130
 
3131
# Check if 'sun' was requested on non-Solaris 2 platforms.
3132
if test x$enable_symvers = xsun ; then
3133
  case ${target_os} in
3134
    solaris2*)
3135
      # All fine.
3136
      ;;
3137
    *)
3138
      # Unlikely to work.
3139
      AC_MSG_WARN([=== You have requested Sun symbol versioning, but])
3140
      AC_MSG_WARN([=== you are not targetting Solaris 2.])
3141
      AC_MSG_WARN([=== Symbol versioning will be disabled.])
3142
      enable_symvers=no
3143
      ;;
3144
  esac
3145
fi
3146
 
3147
# Check to see if 'gnu' can win.
3148
if test $enable_symvers = gnu ||
3149
  test $enable_symvers = gnu-versioned-namespace ||
3150
  test $enable_symvers = sun; then
3151
  # Check to see if libgcc_s exists, indicating that shared libgcc is possible.
3152
  AC_MSG_CHECKING([for shared libgcc])
3153
  ac_save_CFLAGS="$CFLAGS"
3154
  CFLAGS=' -lgcc_s'
3155
  AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes, glibcxx_shared_libgcc=no)
3156
  CFLAGS="$ac_save_CFLAGS"
3157
  if test $glibcxx_shared_libgcc = no; then
3158
    cat > conftest.c <<EOF
3159
int main (void) { return 0; }
3160
EOF
3161
changequote(,)dnl
3162
    glibcxx_libgcc_s_suffix=`${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
3163
                             -shared -shared-libgcc -o conftest.so \
3164
                             conftest.c -v 2>&1 >/dev/null \
3165
                             | sed -n 's/^.* -lgcc_s\([^ ]*\) .*$/\1/p'`
3166
changequote([,])dnl
3167
    rm -f conftest.c conftest.so
3168
    if test x${glibcxx_libgcc_s_suffix+set} = xset; then
3169
      CFLAGS=" -lgcc_s$glibcxx_libgcc_s_suffix"
3170
      AC_TRY_LINK(, [return 0;], glibcxx_shared_libgcc=yes)
3171
      CFLAGS="$ac_save_CFLAGS"
3172
    fi
3173
  fi
3174
  AC_MSG_RESULT($glibcxx_shared_libgcc)
3175
 
3176
  # For GNU ld, we need at least this version.  The format is described in
3177
  # GLIBCXX_CHECK_LINKER_FEATURES above.
3178
  glibcxx_min_gnu_ld_version=21400
3179
 
3180
  # If no shared libgcc, can't win.
3181
  if test $glibcxx_shared_libgcc != yes; then
3182
      AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3183
      AC_MSG_WARN([=== you are not building a shared libgcc_s.])
3184
      AC_MSG_WARN([=== Symbol versioning will be disabled.])
3185
      enable_symvers=no
3186
  elif test $with_gnu_ld != yes && test $enable_symvers = sun; then
3187
    : All interesting versions of Sun ld support sun style symbol versioning.
3188
  elif test $with_gnu_ld != yes ; then
3189
    # just fail for now
3190
    AC_MSG_WARN([=== You have requested GNU symbol versioning, but])
3191
    AC_MSG_WARN([=== you are not using the GNU linker.])
3192
    AC_MSG_WARN([=== Symbol versioning will be disabled.])
3193
    enable_symvers=no
3194
  elif test $glibcxx_ld_is_gold = yes ; then
3195
    : All versions of gold support symbol versioning.
3196
  elif test $glibcxx_gnu_ld_version -lt $glibcxx_min_gnu_ld_version ; then
3197
    # The right tools, the right setup, but too old.  Fallbacks?
3198
    AC_MSG_WARN(=== Linker version $glibcxx_gnu_ld_version is too old for)
3199
    AC_MSG_WARN(=== full symbol versioning support in this release of GCC.)
3200
    AC_MSG_WARN(=== You would need to upgrade your binutils to version)
3201
    AC_MSG_WARN(=== $glibcxx_min_gnu_ld_version or later and rebuild GCC.)
3202
    AC_MSG_WARN([=== Symbol versioning will be disabled.])
3203
    enable_symvers=no
3204
  fi
3205
fi
3206
 
3207
# For libtool versioning info, format is CURRENT:REVISION:AGE
3208
libtool_VERSION=6:17:0
3209
 
3210
# Everything parsed; figure out what files and settings to use.
3211
case $enable_symvers in
3212
  no)
3213
    SYMVER_FILE=config/abi/pre/none.ver
3214
    ;;
3215
  gnu)
3216
    SYMVER_FILE=config/abi/pre/gnu.ver
3217
    AC_DEFINE(_GLIBCXX_SYMVER_GNU, 1,
3218
              [Define to use GNU versioning in the shared library.])
3219
    ;;
3220
  gnu-versioned-namespace)
3221
    libtool_VERSION=7:0:0
3222
    SYMVER_FILE=config/abi/pre/gnu-versioned-namespace.ver
3223
    AC_DEFINE(_GLIBCXX_SYMVER_GNU_NAMESPACE, 1,
3224
              [Define to use GNU namespace versioning in the shared library.])
3225
    ;;
3226
  darwin)
3227
    SYMVER_FILE=config/abi/pre/gnu.ver
3228
    AC_DEFINE(_GLIBCXX_SYMVER_DARWIN, 1,
3229
              [Define to use darwin versioning in the shared library.])
3230
    ;;
3231
  sun)
3232
    SYMVER_FILE=config/abi/pre/gnu.ver
3233
    AC_DEFINE(_GLIBCXX_SYMVER_SUN, 1,
3234
              [Define to use Sun versioning in the shared library.])
3235
    ;;
3236
esac
3237
 
3238
if test x$enable_symvers != xno ; then
3239
  AC_DEFINE(_GLIBCXX_SYMVER, 1,
3240
         [Define to use symbol versioning in the shared library.])
3241
fi
3242
 
3243
AC_CACHE_CHECK([whether the target supports .symver directive],
3244
               glibcxx_cv_have_as_symver_directive, [
3245
  AC_TRY_COMPILE([void foo (void); __asm (".symver foo, bar@SYMVER");],
3246
                 [], glibcxx_cv_have_as_symver_directive=yes,
3247
                 glibcxx_cv_have_as_symver_directive=no)])
3248
if test $glibcxx_cv_have_as_symver_directive = yes; then
3249
  AC_DEFINE(HAVE_AS_SYMVER_DIRECTIVE, 1,
3250
    [Define to 1 if the target assembler supports .symver directive.])
3251
fi
3252
 
3253
AC_SUBST(SYMVER_FILE)
3254
AC_SUBST(port_specific_symbol_files)
3255
GLIBCXX_CONDITIONAL(ENABLE_SYMVERS, test $enable_symvers != no)
3256
GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU, test $enable_symvers = gnu)
3257
GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_GNU_NAMESPACE, test $enable_symvers = gnu-versioned-namespace)
3258
GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_DARWIN, test $enable_symvers = darwin)
3259
GLIBCXX_CONDITIONAL(ENABLE_SYMVERS_SUN, test $enable_symvers = sun)
3260
AC_MSG_NOTICE(versioning on shared library symbols is $enable_symvers)
3261
 
3262
if test $enable_symvers != no ; then
3263
   case ${target_os} in
3264
     # The Solaris 2 runtime linker doesn't support the GNU extension of
3265
     # binding the same symbol to different versions
3266
     solaris2*)
3267
       ;;
3268
     # Other platforms with GNU symbol versioning (GNU/Linux, more?) do.
3269
     *)
3270
       AC_DEFINE(HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT, 1,
3271
         [Define to 1 if the target runtime linker supports binding the same symbol to different versions.])
3272
       ;;
3273
    esac
3274
fi
3275
 
3276
# Now, set up compatibility support, if any.
3277
# In addition, need this to deal with std::size_t mangling in
3278
# src/compatibility.cc.  In a perfect world, could use
3279
# typeid(std::size_t).name()[0] to do direct substitution.
3280
AC_MSG_CHECKING([for size_t as unsigned int])
3281
ac_save_CFLAGS="$CFLAGS"
3282
CFLAGS="-Werror"
3283
AC_TRY_COMPILE(, [__SIZE_TYPE__* stp; unsigned int* uip; stp = uip;],
3284
                 [glibcxx_size_t_is_i=yes], [glibcxx_size_t_is_i=no])
3285
CFLAGS=$ac_save_CFLAGS
3286
if test "$glibcxx_size_t_is_i" = yes; then
3287
  AC_DEFINE(_GLIBCXX_SIZE_T_IS_UINT, 1, [Define if size_t is unsigned int.])
3288
fi
3289
AC_MSG_RESULT([$glibcxx_size_t_is_i])
3290
 
3291
AC_MSG_CHECKING([for ptrdiff_t as int])
3292
ac_save_CFLAGS="$CFLAGS"
3293
CFLAGS="-Werror"
3294
AC_TRY_COMPILE(, [__PTRDIFF_TYPE__* ptp; int* ip; ptp = ip;],
3295
                 [glibcxx_ptrdiff_t_is_i=yes], [glibcxx_ptrdiff_t_is_i=no])
3296
CFLAGS=$ac_save_CFLAGS
3297
if test "$glibcxx_ptrdiff_t_is_i" = yes; then
3298
  AC_DEFINE(_GLIBCXX_PTRDIFF_T_IS_INT, 1, [Define if ptrdiff_t is int.])
3299
fi
3300
AC_MSG_RESULT([$glibcxx_ptrdiff_t_is_i])
3301
])
3302
 
3303
 
3304
dnl
3305
dnl Setup to use the gcc gthr.h thread-specific memory and mutex model.
3306
dnl We must stage the required headers so that they will be installed
3307
dnl with the library (unlike libgcc, the STL implementation is provided
3308
dnl solely within headers).  Since we must not inject random user-space
3309
dnl macro names into user-provided C++ code, we first stage into <file>-in
3310
dnl and process to <file> with an output command.  The reason for a two-
3311
dnl stage process here is to correctly handle $srcdir!=$objdir without
3312
dnl having to write complex code (the sed commands to clean the macro
3313
dnl namespace are complex and fragile enough as it is).  We must also
3314
dnl add a relative path so that -I- is supported properly.
3315
dnl
3316
AC_DEFUN([GLIBCXX_ENABLE_THREADS], [
3317
  AC_MSG_CHECKING([for thread model used by GCC])
3318
  target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3319
  AC_MSG_RESULT([$target_thread_file])
3320
])
3321
 
3322
 
3323
dnl
3324
dnl Check if gthread implementation defines the types and functions
3325
dnl required by the c++0x thread library.  Conforming gthread
3326
dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.
3327
dnl
3328
dnl GLIBCXX_ENABLE_SYMVERS must be done before this.
3329
dnl
3330
AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [
3331
  GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])
3332
 
3333
  if test x$enable_libstdcxx_threads = xauto ||
3334
     test x$enable_libstdcxx_threads = xyes; then
3335
 
3336
  AC_LANG_SAVE
3337
  AC_LANG_CPLUSPLUS
3338
 
3339
  ac_save_CXXFLAGS="$CXXFLAGS"
3340
  CXXFLAGS="$CXXFLAGS -fno-exceptions \
3341
        -I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"
3342
 
3343
  target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`
3344
  case $target_thread_file in
3345
    posix)
3346
      CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"
3347
  esac
3348
 
3349
  AC_MSG_CHECKING([whether it can be safely assumed that mutex_timedlock is available])
3350
 
3351
  AC_TRY_COMPILE([#include <unistd.h>],
3352
    [
3353
      // In case of POSIX threads check _POSIX_TIMEOUTS.
3354
      #if (defined(_PTHREADS) \
3355
          && (!defined(_POSIX_TIMEOUTS) || _POSIX_TIMEOUTS <= 0))
3356
      #error
3357
      #endif
3358
    ], [ac_gthread_use_mutex_timedlock=1], [ac_gthread_use_mutex_timedlock=0])
3359
 
3360
  AC_DEFINE_UNQUOTED(_GTHREAD_USE_MUTEX_TIMEDLOCK, $ac_gthread_use_mutex_timedlock,
3361
                     [Define to 1 if mutex_timedlock is available.])
3362
 
3363
  if test $ac_gthread_use_mutex_timedlock = 1 ; then res_mutex_timedlock=yes ;
3364
  else res_mutex_timedlock=no ; fi
3365
  AC_MSG_RESULT([$res_mutex_timedlock])
3366
 
3367
  AC_MSG_CHECKING([for gthreads library])
3368
 
3369
  AC_TRY_COMPILE([#include "gthr.h"],
3370
    [
3371
      #ifndef __GTHREADS_CXX0X
3372
      #error
3373
      #endif
3374
    ], [case $target_os in
3375
          # gthreads support breaks symbol versioning on Solaris 8/9 (PR
3376
          # libstdc++/52189).
3377
          solaris2.[[89]]*)
3378
            if test x$enable_symvers = xno; then
3379
              ac_has_gthreads=yes
3380
            elif test x$enable_libstdcxx_threads = xyes; then
3381
              AC_MSG_WARN([You have requested C++11 threads support, but])
3382
              AC_MSG_WARN([this breaks symbol versioning.])
3383
              ac_has_gthreads=yes
3384
            else
3385
              ac_has_gthreads=no
3386
            fi
3387
            ;;
3388
          *)
3389
            ac_has_gthreads=yes
3390
            ;;
3391
        esac],
3392
       [ac_has_gthreads=no])
3393
  else
3394
    ac_has_gthreads=no
3395
  fi
3396
 
3397
  AC_MSG_RESULT([$ac_has_gthreads])
3398
 
3399
  if test x"$ac_has_gthreads" = x"yes"; then
3400
    AC_DEFINE(_GLIBCXX_HAS_GTHREADS, 1,
3401
              [Define if gthreads library is available.])
3402
  fi
3403
 
3404
  CXXFLAGS="$ac_save_CXXFLAGS"
3405
  AC_LANG_RESTORE
3406
])
3407
 
3408
 
3409
# Check whether LC_MESSAGES is available in <locale.h>.
3410
# Ulrich Drepper <drepper@cygnus.com>, 1995.
3411
#
3412
# This file file be copied and used freely without restrictions.  It can
3413
# be used in projects which are not available under the GNU Public License
3414
# but which still want to provide support for the GNU gettext functionality.
3415
# Please note that the actual code is *not* freely available.
3416
AC_DEFUN([AC_LC_MESSAGES], [
3417
  AC_CHECK_HEADER(locale.h, [
3418
    AC_CACHE_CHECK([for LC_MESSAGES], ac_cv_val_LC_MESSAGES,
3419
      [AC_TRY_COMPILE([#include <locale.h>], [return LC_MESSAGES],
3420
       ac_cv_val_LC_MESSAGES=yes, ac_cv_val_LC_MESSAGES=no)])
3421
    if test $ac_cv_val_LC_MESSAGES = yes; then
3422
      AC_DEFINE(HAVE_LC_MESSAGES, 1,
3423
                [Define if LC_MESSAGES is available in <locale.h>.])
3424
    fi
3425
  ])
3426
])
3427
 
3428
dnl
3429
dnl Check whether get_nprocs is available in <sys/sysinfo.h>, and define _GLIBCXX_USE_GET_NPROCS.
3430
dnl
3431
AC_DEFUN([GLIBCXX_CHECK_GET_NPROCS], [
3432
 
3433
  AC_LANG_SAVE
3434
  AC_LANG_CPLUSPLUS
3435
  ac_save_CXXFLAGS="$CXXFLAGS"
3436
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
3437
 
3438
  AC_MSG_CHECKING([for get_nprocs])
3439
  AC_CACHE_VAL(glibcxx_cv_GET_NPROCS, [
3440
    GCC_TRY_COMPILE_OR_LINK(
3441
      [#include <sys/sysinfo.h>],
3442
      [int n = get_nprocs();],
3443
      [glibcxx_cv_GET_NPROCS=yes],
3444
      [glibcxx_cv_GET_NPROCS=no])
3445
  ])
3446
  if test $glibcxx_cv_GET_NPROCS = yes; then
3447
    AC_DEFINE(_GLIBCXX_USE_GET_NPROCS, 1, [Define if get_nprocs is available in <sys/sysinfo.h>.])
3448
  fi
3449
  AC_MSG_RESULT($glibcxx_cv_GET_NPROCS)
3450
 
3451
  CXXFLAGS="$ac_save_CXXFLAGS"
3452
  AC_LANG_RESTORE
3453
])
3454
 
3455
dnl
3456
dnl Check whether sysconf(_SC_NPROCESSORS_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROCESSORS_ONLN.
3457
dnl
3458
AC_DEFUN([GLIBCXX_CHECK_SC_NPROCESSORS_ONLN], [
3459
 
3460
  AC_LANG_SAVE
3461
  AC_LANG_CPLUSPLUS
3462
  ac_save_CXXFLAGS="$CXXFLAGS"
3463
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
3464
 
3465
  AC_MSG_CHECKING([for _SC_NPROCESSORS_ONLN])
3466
  AC_CACHE_VAL(glibcxx_cv_SC_NPROCESSORS_ONLN, [
3467
    GCC_TRY_COMPILE_OR_LINK(
3468
      [#include <unistd.h>],
3469
      [int n = sysconf(_SC_NPROCESSORS_ONLN);],
3470
      [glibcxx_cv_SC_NPROCESSORS_ONLN=yes],
3471
      [glibcxx_cv_SC_NPROCESSORS_ONLN=no])
3472
  ])
3473
  if test $glibcxx_cv_SC_NPROCESSORS_ONLN = yes; then
3474
    AC_DEFINE(_GLIBCXX_USE_SC_NPROCESSORS_ONLN, 1, [Define if _SC_NPROCESSORS_ONLN  is available in <unistd.h>.])
3475
  fi
3476
  AC_MSG_RESULT($glibcxx_cv_SC_NPROCESSORS_ONLN)
3477
 
3478
  CXXFLAGS="$ac_save_CXXFLAGS"
3479
  AC_LANG_RESTORE
3480
])
3481
 
3482
dnl
3483
dnl Check whether sysconf(_SC_NPROC_ONLN) is available in <unistd.h>, and define _GLIBCXX_USE_SC_NPROC_ONLN.
3484
dnl
3485
AC_DEFUN([GLIBCXX_CHECK_SC_NPROC_ONLN], [
3486
 
3487
  AC_LANG_SAVE
3488
  AC_LANG_CPLUSPLUS
3489
  ac_save_CXXFLAGS="$CXXFLAGS"
3490
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
3491
 
3492
  AC_MSG_CHECKING([for _SC_NPROC_ONLN])
3493
  AC_CACHE_VAL(glibcxx_cv_SC_NPROC_ONLN, [
3494
    GCC_TRY_COMPILE_OR_LINK(
3495
      [#include <unistd.h>],
3496
      [int n = sysconf(_SC_NPROC_ONLN);],
3497
      [glibcxx_cv_SC_NPROC_ONLN=yes],
3498
      [glibcxx_cv_SC_NPROC_ONLN=no])
3499
  ])
3500
  if test $glibcxx_cv_SC_NPROC_ONLN = yes; then
3501
    AC_DEFINE(_GLIBCXX_USE_SC_NPROC_ONLN, 1, [Define if _SC_NPROC_ONLN  is available in <unistd.h>.])
3502
  fi
3503
  AC_MSG_RESULT($glibcxx_cv_SC_NPROC_ONLN)
3504
 
3505
  CXXFLAGS="$ac_save_CXXFLAGS"
3506
  AC_LANG_RESTORE
3507
])
3508
 
3509
dnl
3510
dnl Check whether pthread_num_processors_np is available in <pthread.h>, and define _GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP.
3511
dnl
3512
AC_DEFUN([GLIBCXX_CHECK_PTHREADS_NUM_PROCESSORS_NP], [
3513
 
3514
  AC_LANG_SAVE
3515
  AC_LANG_CPLUSPLUS
3516
  ac_save_CXXFLAGS="$CXXFLAGS"
3517
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
3518
 
3519
  AC_MSG_CHECKING([for pthreads_num_processors_np])
3520
  AC_CACHE_VAL(glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP, [
3521
    GCC_TRY_COMPILE_OR_LINK(
3522
      [#include <pthread.h>],
3523
      [int n = pthread_num_processors_np();],
3524
      [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=yes],
3525
      [glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP=no])
3526
  ])
3527
  if test $glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP = yes; then
3528
    AC_DEFINE(_GLIBCXX_USE_PTHREADS_NUM_PROCESSORS_NP, 1, [Define if pthreads_num_processors_np is available in <pthread.h>.])
3529
  fi
3530
  AC_MSG_RESULT($glibcxx_cv_PTHREADS_NUM_PROCESSORS_NP)
3531
 
3532
  CXXFLAGS="$ac_save_CXXFLAGS"
3533
  AC_LANG_RESTORE
3534
])
3535
 
3536
dnl
3537
dnl Check whether sysctl is available in <pthread.h>, and define _GLIBCXX_USE_SYSCTL_HW_NCPU.
3538
dnl
3539
AC_DEFUN([GLIBCXX_CHECK_SYSCTL_HW_NCPU], [
3540
 
3541
  AC_LANG_SAVE
3542
  AC_LANG_CPLUSPLUS
3543
  ac_save_CXXFLAGS="$CXXFLAGS"
3544
  CXXFLAGS="$CXXFLAGS -fno-exceptions"
3545
 
3546
  AC_MSG_CHECKING([for hw.ncpu sysctl])
3547
  AC_CACHE_VAL(glibcxx_cv_SYSCTL_HW_NCPU, [
3548
    GCC_TRY_COMPILE_OR_LINK(
3549
      [
3550
       #include <stddef.h>
3551
       #include <sys/sysctl.h>
3552
       ],
3553
      [
3554
       int count;
3555
       size_t size = sizeof(count);
3556
       int mib[] = { CTL_HW, HW_NCPU };
3557
       sysctl(mib, 2, &count, &size, NULL, 0);
3558
      ],
3559
      [glibcxx_cv_SYSCTL_HW_NCPU=yes],
3560
      [glibcxx_cv_SYSCTL_HW_NCPU=no])
3561
  ])
3562
  if test $glibcxx_cv_SYSCTL_HW_NCPU = yes; then
3563
    AC_DEFINE(_GLIBCXX_USE_SYSCTL_HW_NCPU, 1, [Define if sysctl(), CTL_HW and HW_NCPU are available in <sys/sysctl.h>.])
3564
  fi
3565
  AC_MSG_RESULT($glibcxx_cv_SYSCTL_HW_NCPU)
3566
 
3567
  CXXFLAGS="$ac_save_CXXFLAGS"
3568
  AC_LANG_RESTORE
3569
])
3570
 
3571
dnl
3572
dnl Check to see if python pretty printing can be activated.
3573
dnl
3574
dnl --with-python-dir=dir
3575
dnl installs directory into $prefix/dir
3576
AC_DEFUN([GLIBCXX_ENABLE_PYTHON], [
3577
 
3578
AC_MSG_CHECKING([for custom python install directory])
3579
AC_ARG_WITH([python-dir],
3580
            AS_HELP_STRING([--with-python-dir],
3581
                           [the location to install Python modules. This path is relative starting from the prefix.]),
3582
            [with_python_dir=$withval], [with_python_dir="no"])
3583
AC_MSG_RESULT(${with_python_dir})
3584
 
3585
# Needed for installing Python modules during make install.
3586
python_mod_dir="${with_python_dir}"
3587
AC_SUBST(python_mod_dir)
3588
GLIBCXX_CONDITIONAL(ENABLE_PYTHONDIR, test $python_mod_dir != no)
3589
])
3590
 
3591
dnl
3592
dnl Check to see if -Werror is disabled.
3593
dnl
3594
dnl --enable-werror/--disable-werror
3595
AC_DEFUN([GLIBCXX_ENABLE_WERROR], [
3596
  AC_MSG_CHECKING([for -Werror])
3597
  GLIBCXX_ENABLE(werror,$1,,[turns on -Werror])
3598
  AC_MSG_RESULT($enable_werror)
3599
  GLIBCXX_CONDITIONAL(ENABLE_WERROR, test $enable_werror = yes)
3600
])
3601
 
3602
 
3603
# Macros from the top-level gcc directory.
3604
m4_include([../config/gc++filt.m4])
3605
m4_include([../config/tls.m4])

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.