summary refs log tree commit diff
path: root/configure.in
blob: f36bcaf1bf12d9dea219c05f64cb1a75a900eff4 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
Dnl Process this file with autoconf to produce a configure script.
AC_REVISION([$CVSid$])
AC_PREREQ(2.11)dnl		dnl Minimum Autoconf version required.
AC_INIT(features.h)
AC_CONFIG_HEADER(config.h)

# This will get text that should go into config.make.
config_vars=

# Check for a --with-gmp argument and set gmp-srcdir in config.make.
AC_ARG_WITH(gmp, dnl
  --with-gmp=DIRECTORY	  find GMP source code in DIRECTORY (not needed),
	    [dnl
case "$with_gmp" in
yes) AC_MSG_ERROR(--with-gmp requires an argument; use --with-gmp=DIRECTORY) ;;
''|no) ;;
*) config_vars="$config_vars
gmp-srcdir = $withval" ;;
esac
])
# Check for a --with-gettext argument and set gettext-srcdir in config.make.
AC_ARG_WITH(gettext, dnl
  --with-gettext=DIR	  find GNU gettext source code in DIR (not needed),
	    [dnl
case "$with_gettext" in
yes)
  AC_MSG_ERROR(--with-gettext requires an argument; use --with-gettext=DIR) ;;
''|no) ;;
*)
  config_vars="$config_vars
gettext-srcdir = $withval" ;;
esac
])

dnl Arguments to specify presence of other packages/features.
AC_ARG_WITH(fp, dnl
[  --with-fp		  if using floating-point hardware [default=yes]],
	    with_fp=$withval, with_fp=yes)
AC_ARG_WITH(gnu-binutils, dnl
  --with-gnu-binutils	  if using GNU binutils (as and ld),
	    gnu_binutils=$withval, gnu_binutils=no)
AC_ARG_WITH(gnu-ld, dnl
  --with-gnu-ld		  if using GNU ld (in the binutils package),
	    gnu_ld=$withval, gnu_ld=no)
AC_ARG_WITH(gnu-as, dnl
  --with-gnu-as		  if using GNU as (in the binutils package),
	    gnu_as=$withval, gnu_as=no)
test $gnu_binutils = yes && gnu_as=yes gnu_ld=yes
AC_ARG_WITH(elf, dnl
  --with-elf		  if using the ELF object format,
	    elf=$withval, elf=no)

AC_ARG_ENABLE(libio, dnl
[  --enable-libio          build in GNU libio instead of GNU stdio],
 	      [if test $enableval = yes; then
	         stdio=libio
	       else
	         stdio=stdio
	       fi],
	      stdio=default)

AC_ARG_ENABLE(sanity-checks, dnl
[  --disable-sanity-checks really do not use threads (should not be used
			  except in special situations) [default=yes]],
              enable_sanity=$enableval, enable_sanity=yes)

dnl Arguments to enable or disable building the shared, profiled, and
dnl -fomit-frame-pointer libraries.
AC_ARG_ENABLE(shared, dnl
[  --enable-shared         build shared library [default=yes if GNU ld & ELF]],
	      shared=$enableval, shared=default)
AC_ARG_ENABLE(profile, dnl
[  --enable-profile        build profiled library [default=yes]],
	      profile=$enableval, profile=yes)
AC_ARG_ENABLE(omitfp, dnl
[  --enable-omitfp         build undebuggable optimized library [default=no]],
	      omitfp=$enableval, omitfp=no)
AC_ARG_ENABLE(bounded, dnl
[  --enable-bounded        build with runtime bounds checking [default=no]],
	      bounded=$enableval, bounded=no)

dnl Generic infrastructure for drop-in additions to libc.
AC_ARG_ENABLE(add-ons, dnl
[  --enable-add-ons=DIR... configure and build named extra directories],
   	      [add_ons=`echo "$enableval" | sed 's/,/ /g'`],
	      [add_ons=])
AC_CONFIG_SUBDIRS($add_ons)
add_ons_pfx=
if test x"$add_ons" != x; then
  for f in $add_ons; do
    add_ons_pfx="$add_ons_pfx $f/"
  done
fi

AC_CANONICAL_HOST

# The way shlib-versions is used to generate soversions.mk uses a
# fairly simplistic model for name recognition that can't distinguish
# i486-pc-linux-gnu fully from i486-pc-gnu.  So we mutate a $host_os
# of `gnu*' here to be `gnu-gnu*' just so that shlib-versions can
# tell.  This doesn't get used much beyond that, so it's fairly safe.
case "$host_os" in
linux*)
  ;;
gnu*)
  host_os=`echo $host_os | sed -e 's/gnu/gnu-gnu/'`
  ;;
esac

# We keep the original values in `$config_*' and never modify them, so we
# can write them unchanged into config.make.  Everything else uses
# $machine, $vendor, and $os, and changes them whenever convenient.
config_machine=$host_cpu config_vendor=$host_vendor config_os=$host_os

# Some configurations imply other options.
case "$host_os" in
gnu* | linux* | bsd4.4* | netbsd* | freebsd*)
  # These systems always use GNU tools.
  gnu_ld=yes gnu_as=yes ;;
esac
case "$host_os" in
linux*ecoff*)
  ;;
gnu* | linux* | sysv4* | solaris2*)
  # These systems (almost) always use the ELF format.
  elf=yes
  ;;
esac

machine=$config_machine
vendor=$config_vendor
os=$config_os

dnl We need to use [ and ] for other purposes for a while now.
changequote(,)dnl
# Expand the configuration machine name into a subdirectory by architecture
# type and particular chip.
case "$machine" in
a29k | am29000)	base_machine=a29k machine=a29k ;;
alpha*)		base_machine=alpha machine=alpha/$machine ;;
hppa*)		base_machine=hppa machine=hppa/$machine ;;
i[3456]86)	base_machine=i386 machine=i386/$machine ;;
m680?0)		base_machine=m68k machine=m68k/$machine ;;
m68k)		base_machine=m68k machine=m68k/m68020 ;;
m88???)		base_machine=m88k machine=m88k/$machine ;;
m88k)		base_machine=m88k machine=m88k/m88100 ;;
mips*)		base_machine=mips machine=mips/$machine ;;
mips64*)	base_machine=mips64 machine=mips/mips64/$machine ;;
sparc[6789])	base_machine=sparc machine=sparc/$machine ;;
supersparc)	base_machine=sparc machine=sparc/sparc8 ;;
esac
changequote([,])dnl
AC_SUBST(base_machine)

# Compute the list of sysdep directories for this configuration.
# This can take a while to compute.
sysdep_dir=$srcdir/sysdeps
AC_MSG_CHECKING(sysdep dirs)
dnl We need to use [ and ] for other purposes for a while now.
changequote(,)dnl
# Make sco3.2v4 become sco3.2.4 and sunos4.1.1_U1 become sunos4.1.1.U1.
os="`echo $os | sed 's/\([0-9A-Z]\)[v_]\([0-9A-Z]\)/\1.\2/g'`"

case "$os" in
gnu*)
  base_os=mach/hurd ;;
netbsd* | 386bsd* | freebsd* | bsdi*)
  base_os=unix/bsd/bsd4.4 ;;
osf* | sunos* | ultrix* | newsos* | dynix* | *bsd*)
  base_os=unix/bsd ;;
sysv* | isc* | esix* | sco* | minix* | irix4* | linux*)
  base_os=unix/sysv ;;
solaris[2-9]*)
  base_os=unix/sysv/sysv4 ;;
none)
  base_os=standalone ;;
*)
  base_os='' ;;
esac

# For sunos4.1.1, try sunos4.1.1, then sunos4.1, then sunos4, then sunos.
tail=$os
ostry=$os
while o=`echo $tail | sed 's/\.[^.]*$//'`; test $o != $tail; do
  ostry="$ostry /$o"
  tail=$o
done
o=`echo $tail | sed 's/[0-9]*$//'`
if test $o != $tail; then
  ostry="$ostry /$o"
fi
# For linux-gnu, try linux-gnu, then linux.
o=`echo $tail | sed 's/-.*$//'`
if test $o != $tail; then
  ostry="$ostry /$o"
fi

# For unix/sysv/sysv4, try unix/sysv/sysv4, then unix/sysv, then unix.
base=
tail=$base_os
while b=`echo $tail | sed 's@^\(.*\)/\([^/]*\)$@& \1@'`; test -n "$b"; do
  set $b
  base="$base /$1"
  tail="$2"
done

# For sparc/sparc9, try sparc/sparc9 and then sparc.
mach=
tail=$machine
while m=`echo $tail | sed 's@^\(.*\)/\([^/]*\)$@& \1@'`; test -n "$m"; do
  set $m
  # Prepend the machine's FPU directory unless --without-fp.
  if test "$with_fp" = yes; then
    mach="$mach /$1/fpu"
  fi
  mach="$mach /$1"
  tail="$2"
done

dnl We are done with glob and regexp uses of [ and ]; return to autoconf.
changequote([,])dnl

# Find what sysdep directories exist.
sysnames=
IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
for d in $add_ons_pfx ''; do
  for b in $base ''; do
    for m0 in $mach ''; do
      for v in /$vendor ''; do
	for o in /$ostry ''; do
	  for m in $mach ''; do
	    if test "$m0$b$v$o$m"; then
	      try="${d}sysdeps$m0$b$v$o$m"
	      test -n "$enable_debug_configure" &&
	      echo "$0 [DEBUG]: try $try" >&2
	      case $try in
		/*) dest=$try ;;
		*)  dest=$srcdir/$try ;;
	      esac
	      if test -d $dest; then
		sysnames="$sysnames $try"
		{ test -n "$o" || test -n "$b"; } && os_used=t
		{ test -n "$m" || test -n "$m0"; } && machine_used=t
	      fi
	    fi
	  done
	done
      done
    done
  done
done
IFS="$ac_save_ifs"

if test -z "$os_used" && test "$os" != none; then
  AC_MSG_ERROR(Operating system $os is not supported.)
fi
if test -z "$machine_used" && test "$machine" != none; then
  AC_MSG_ERROR(The $machine is not supported.)
fi

# We have now validated the configuration.


# If using ELF, look for an `elf' subdirectory of each machine directory.
# We prepend these rather than inserting them whereever the machine appears
# because things specified by the machine's ELF ABI should override
# OS-specific things, and should always be the same for any OS on the
# machine (otherwise what's the point of an ABI?).
if test "$elf" = yes; then
  elf_dirs=
  for d in $add_ons_pfx ''; do
    case $d in
      /*) xsrcdir= ;;
      *)  xsrcdir=$srcdir/ ;;
    esac
    for m in $mach; do
      if test -d $xsrcdir${d}sysdeps$m/elf; then
	elf_dirs="$elf_dirs ${d}sysdeps$m/elf"
      fi
    done
  done
  sysnames="`echo $elf_dirs | sed -e 's,//,/,g'` $sysnames"
fi


# Expand the list of system names into a full list of directories
# from each element's parent name and Implies file (if present).
set $sysnames
names=
while test $# -gt 0; do
  name=$1
  shift

  case " $names " in *" $name "*)
    # Already in the list.
    continue
  esac

  # Report each name as we discover it, so there is no long pause in output.
  echo $ac_n "$name $ac_c" >&AC_FD_MSG

  name_base=`echo $name | sed -e 's@\(.*sysdeps\)/.*@\1@'`

  case $name in
    /*) xsrcdir= ;;
    *)  xsrcdir=$srcdir/ ;;
  esac
  test -n "$enable_debug_configure" &&
  echo "[DEBUG]: name/Implies $xsrcdir$name/Implies" >&2

  if test -f $xsrcdir$name/Implies; then
    # Collect more names from the `Implies' file (removing comments).
    implied_candidate="`sed 's/#.*$//' < $xsrcdir$name/Implies`"
    implied=
    for x in $implied_candidate; do
      if test -d $xsrcdir$name_base/$x; then
	implied="$implied $name_base/$x";
      else
        AC_MSG_WARN($name/Implies specifies nonexistent $x)
      fi
    done
  else
    implied=
  fi

  # Add NAME to the list of names.
  names="$names $name"

  # Find the parent of NAME, using the empty string if it has none.
changequote(,)dnl
  parent="`echo $name | sed -n -e 's=/[^/]*$==' -e '/sysdeps$/q' -e p`"
changequote([,])dnl

  # Add the names implied by NAME, and NAME's parent (if it has one), to
  # the list of names to be processed (the argument list).  We prepend the
  # implied names to the list and append the parent.  We want implied
  # directories to come before further directories inferred from the
  # configuration components; this ensures that for sysv4, unix/common
  # (implied by unix/sysv/sysv4) comes before unix/sysv (in ostry (here $*)
  # after sysv4).
  sysnames="`echo $implied $* $parent`"
  test -n "$sysnames" && set $sysnames
done

# Add the default directories.
sysnames="$names sysdeps/generic sysdeps/stub"
AC_SUBST(sysnames)
# The other names were emitted during the scan.
AC_MSG_RESULT(sysdeps/generic sysdeps/stub)


### Locate tools.

AC_PROG_INSTALL
if test "$INSTALL" = "${srcdir}/install-sh -c"; then
  # The makefiles need to use a different form to find it in $srcdir.
  INSTALL='$(..)./install-sh -c'
fi
AC_PROG_LN_S
AC_CHECK_PROGS(MSGFMT, msgfmt gmsgfmt, :)

AC_CHECK_TOOL(CC, gcc)
if test $host != $build; then
  AC_CHECK_PROG(BUILD_CC, gcc cc)
fi
AC_PROG_CPP
AC_CHECK_TOOL(AR, ar)
AC_CHECK_TOOL(RANLIB, ranlib, :)

AC_PATH_PROG(BASH, bash, no)
if test "$BASH" != no &&
   $BASH -c 'test "$BASH_VERSINFO" -ge 2 >&/dev/null'; then
  libc_cv_have_bash2=yes
else
  libc_cv_have_bash2=no
fi
AC_SUBST(libc_cv_have_bash2)

dnl We need a ksh compatible shell for tzselect.
if test "$BASH" = no; then
  AC_PATH_PROG(KSH, ksh, no)
  if test "$KSH" = no; then
    libc_cv_have_ksh=no
  else
    libc_cv_have_ksh=yes
  fi
else
  KSH="$BASH"
  AC_SUBST(KSH)
  libc_cv_have_ksh=yes
fi
AC_SUBST(libc_cv_have_ksh)

AC_CACHE_CHECK(for signed size_t type, libc_cv_signed_size_t, [dnl
echo '#include <stddef.h>
FOOBAR __SIZE_TYPE__ FOOBAR' > conftest.c
if eval "$ac_cpp conftest.c 2>/dev/null" \
| grep '^FOOBAR.*unsigned.*FOOBAR$' >/dev/null; then
  libc_cv_signed_size_t=no
else
  libc_cv_signed_size_t=yes
fi
rm -f conftest*])
if test $libc_cv_signed_size_t = yes; then
  dnl Do this by hand instead of AC_DEFINE so can add #undef to avoid warnings.
  cat >> confdefs.h <<\EOF
#undef __SIZE_TYPE__
#define __SIZE_TYPE__ unsigned
EOF
fi

AC_CACHE_CHECK(for libc-friendly stddef.h, libc_cv_friendly_stddef, [dnl
AC_TRY_COMPILE(dnl
[#define __need_size_t
#define __need_wchar_t
#include <stddef.h>
#define __need_NULL
#include <stddef.h>], [size_t size; wchar_t wchar;
#ifdef offsetof
#error stddef.h ignored __need_*
#endif
if (&size == NULL || &wchar == NULL) abort ();],
               libc_cv_friendly_stddef=yes,
               libc_cv_friendly_stddef=no)])
if test $libc_cv_friendly_stddef = yes; then
  config_vars="$config_vars
override stddef.h = # The installed <stddef.h> seems to be libc-friendly."
fi

AC_CACHE_CHECK(whether we need to use -P to assemble .S files,
	       libc_cv_need_minus_P, [dnl
cat > conftest.S <<EOF
#include "confdefs.h"
/* Nothing whatsoever.  */
EOF
if ${CC-cc} $CFLAGS -c conftest.S 2>/dev/null; then
  libc_cv_need_minus_P=no
else
  libc_cv_need_minus_P=yes
fi
rm -f conftest*])
if test $libc_cv_need_minus_P = yes; then
  config_vars="$config_vars
asm-CPPFLAGS = -P # The assembler can't grok cpp's # line directives."
fi

AC_CACHE_CHECK(for assembler global-symbol directive,
	       libc_cv_asm_global_directive, [dnl
libc_cv_asm_global_directive=UNKNOWN
for ac_globl in .globl .global; do
  cat > conftest.s <<EOF
.text
${ac_globl} foo
foo: .long 0
EOF
  if ${CC-cc} $CFLAGS -c conftest.s 2>/dev/null; then
    libc_cv_asm_global_directive=${ac_globl}
  fi
  rm -f conftest*
  test $libc_cv_asm_global_directive != UNKNOWN && break
done])
if test $libc_cv_asm_global_directive = UNKNOWN; then
  AC_MSG_ERROR(cannot determine asm global directive)
else
  AC_DEFINE_UNQUOTED(ASM_GLOBAL_DIRECTIVE, ${libc_cv_asm_global_directive})
fi

AC_CACHE_CHECK(for .set assembler directive, libc_cv_asm_set_directive, [dnl
cat > conftest.s <<EOF
.text
foo: .long 0
.set glibc_conftest_frobozz,foo
$libc_cv_asm_global_directive glibc_conftest_frobozz
EOF
# The alpha-dec-osf1 assembler gives only a warning for `.set'
# (but it doesn't work), so we must do a linking check to be sure.
cat > conftest1.c <<\EOF
extern int glibc_conftest_frobozz;
main () { printf ("%d\n", glibc_conftest_frobozz); }
EOF
if ${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS \
	    -o conftest conftest.s conftest1.c 1>&AC_FD_CC 2>&AC_FD_CC; then
  libc_cv_asm_set_directive=yes
else
  libc_cv_asm_set_directive=no
fi
rm -f conftest*])
if test $libc_cv_asm_set_directive = yes; then
  AC_DEFINE(HAVE_ASM_SET_DIRECTIVE)
fi

AC_CACHE_CHECK(for .symver assembler directive, libc_cv_asm_symver_directive,
[cat > conftest.s <<EOF
.text
_sym:
.symver _sym,sym@VERS
EOF
if ${CC-cc} -c $CFLAGS $CPPFLAGS conftest.s 1>&AC_FD_CC 2>&AC_FD_CC; then
  libc_cv_asm_symver_directive=yes
else
  libc_cv_asm_symver_directive=no
fi
rm -f conftest*])
AC_CACHE_CHECK(for ld --version-script, libc_cv_ld_version_script_option, [dnl
if test $libc_cv_asm_symver_directive = yes; then
  cat > conftest.s <<EOF
.text
_sym:
.symver _sym,sym@VERS
EOF
  cat > conftest.map <<EOF
VERS {
	global: sym;
};
EOF
  if ${CC-cc} -c $CFLAGS $CPPFLAGS conftest.s 1>&AC_FD_CC 2>&AC_FD_CC; then
    if AC_TRY_COMMAND([${CC-cc} $CFLAGS --shared -o conftest.so conftest.o
					-Wl,--version-script,conftest.map]);
    then
      libc_cv_ld_version_script_option=yes
    else
      libc_cv_ld_version_script_option=no
    fi
  else
    libc_cv_ld_version_script_option=no
  fi
else
  libc_cv_ld_version_script_option=no
fi
rm -f conftest*])
if test $libc_cv_asm_symver_directive = yes &&
   test $libc_cv_ld_version_script_option = yes; then
  VERSIONING=yes
  AC_DEFINE(DO_VERSIONING)
else
  VERSIONING=no
fi
AC_SUBST(VERSIONING)

if test $elf = yes; then
  AC_CACHE_CHECK(for .previous assembler directive,
		 libc_cv_asm_previous_directive, [dnl
  cat > conftest.s <<EOF
.section foo_section
.previous
EOF
  if AC_TRY_COMMAND(${CC-cc} -c $CFLAGS conftest.s 1>&AC_FD_CC); then
    libc_cv_asm_previous_directive=yes
  else
    libc_cv_asm_previous_directive=no
  fi
  rm -f conftest*])
  if test $libc_cv_asm_previous_directive = yes; then
    AC_DEFINE(HAVE_ASM_PREVIOUS_DIRECTIVE)
  else
    AC_CACHE_CHECK(for .popsection assembler directive,
		   libc_cv_asm_popsection_directive, [dnl
    cat > conftest.s <<EOF
.pushsection foo_section
.popsection
EOF
    if AC_TRY_COMMAND(${CC-cc} -c $CFLAGS conftest.s 1>&AC_FD_CC); then
      libc_cv_asm_popsection_directive=yes
    else
      libc_cv_asm_popsection_directive=no
    fi
    rm -f conftest*])
    if test $libc_cv_asm_popsection_directive = yes; then
      AC_DEFINE(HAVE_ASM_POPSECTION_DIRECTIVE)
    fi
  fi
fi

if test $elf != yes; then
  AC_CACHE_CHECK(for .init and .fini sections, libc_cv_have_initfini,
		 [AC_TRY_COMPILE(, [asm (".section .init");
				    asm (".section .fini");
				    asm (".text");],
				 libc_cv_have_initfini=yes,
				 libc_cv_have_initfini=no)])
  AC_SUBST(libc_cv_have_initfini)dnl
  if test $libc_cv_have_initfini = yes; then
    AC_DEFINE(HAVE_INITFINI)
  fi
fi

if test $elf = yes; then
  libc_cv_asm_underscores=no
else
  AC_CACHE_CHECK(for _ prefix on C symbol names, libc_cv_asm_underscores,
		 [AC_TRY_LINK([asm ("_glibc_foobar:");], [glibc_foobar ();],
			      libc_cv_asm_underscores=yes,
			      libc_cv_asm_underscores=no)])
fi
if test $libc_cv_asm_underscores = no; then
  AC_DEFINE(NO_UNDERSCORES)
fi

if test $elf = yes; then
  libc_cv_weak_symbols=yes
  libc_cv_asm_weak_directive=yes
  libc_cv_asm_weakext_directive=no
else
  AC_CACHE_CHECK(for assembler .weak directive, libc_cv_asm_weak_directive,
		 [dnl
cat > conftest.s <<EOF
.text
${libc_cv_asm_global_directive} foo
foo: .long 0
.weak foo
.weak bar; bar = foo
EOF
  if ${CC-cc} $CFLAGS -c conftest.s 2>/dev/null; then
    libc_cv_asm_weak_directive=yes
  else
    libc_cv_asm_weak_directive=no
  fi
  rm -f conftest*])

if test $libc_cv_asm_weak_directive = no; then
  AC_CACHE_CHECK(for assembler .weakext directive,
		 libc_cv_asm_weakext_directive,
		 [dnl
cat > conftest.s <<EOF
.text
${libc_cv_asm_global_directive} foo
foo: .long 0
.weakext foo
.weakext foo, bar
EOF
  if ${CC-cc} $CFLAGS -c conftest.s 2>/dev/null; then
    libc_cv_asm_weakext_directive=yes
  else
    libc_cv_asm_weakext_directive=no
  fi
  rm -f conftest*])

  fi # no .weak
fi # not ELF

if test $libc_cv_asm_weak_directive = yes; then
  AC_DEFINE(HAVE_ASM_WEAK_DIRECTIVE)
elif test $libc_cv_asm_weakext_directive = yes; then
  AC_DEFINE(HAVE_ASM_WEAKEXT_DIRECTIVE)
fi

AC_CACHE_CHECK(for ld --no-whole-archive, libc_cv_ld_no_whole_archive, [dnl
cat > conftest.c <<\EOF
_start () {}
int __eh_pc;
__throw () {}
EOF
dnl No \ in command here because it ends up inside ''.
if AC_TRY_COMMAND([${CC-cc} $CFLAGS
			    -nostdlib -nostartfiles -Wl,--no-whole-archive
			    -o conftest conftest.c]); then
  libc_cv_ld_no_whole_archive=yes
else
  libc_cv_ld_no_whole_archive=no
fi
rm -f conftest*])
AC_SUBST(libc_cv_ld_no_whole_archive)dnl

AC_CACHE_CHECK(for gcc -fno-exceptions, libc_cv_gcc_no_exceptions, [dnl
cat > conftest.c <<\EOF
_start () {}
int __eh_pc;
__throw () {}
EOF
dnl No \ in command here because it ends up inside ''.
if AC_TRY_COMMAND([${CC-cc} $CFLAGS
			    -nostdlib -nostartfiles -fno-exceptions
			    -o conftest conftest.c]); then
  libc_cv_gcc_no_exceptions=yes
else
  libc_cv_gcc_no_exceptions=no
fi
rm -f conftest*])
AC_SUBST(libc_cv_gcc_no_exceptions)dnl

### End of automated tests.
### Now run sysdeps configure fragments.

# sysdeps configure fragments may set these with files to be linked below.
libc_link_dests=
libc_link_sources=

# Iterate over all the sysdep directories we will use, running their
# configure fragments, and looking for a uname implementation.
uname=
for dir in $sysnames; do
  case $dir in
    /*) dest=$dir ;;
    *)  dest=$srcdir/$dir ;;
  esac
  if test -r $dest/configure; then
    AC_MSG_RESULT(running configure fragment for $dest)
    . $dest/configure
  fi
[
  if test -z "$uname"; then
    if test -r $sysdep_dir/$dir/uname.c ||
       test -r $sysdep_dir/$dir/uname.S ||
       { test -r $sysdep_dir/$dir/syscalls.list &&
	 grep '^uname[ 	]' $sysdep_dir/$dir/syscalls.list >/dev/null; }; then
      uname=$dir
    fi
  fi
]dnl
done

AC_LINK_FILES(`echo $libc_link_sources`, `echo $libc_link_dests`)

# If we will use the generic uname implementation, we must figure out what
# it will say by examining the system, and write the results in config-name.h.
if test "$uname" = generic; then

changequote(,)dnl
  uname_sysname=`echo $config_os | sed 's/[0-9.]*$//'`
changequote([,])dnl
  if test $uname_sysname != $config_os; then
    config_release=`echo $config_os | sed s/$uname_sysname//`
  fi
dnl
AC_DEFUN(LIBC_KERNEL_ID, [dnl
    if test -r /vmunix; then
      kernel_id=`strings /vmunix | grep UNIX`
    elif test -r /dynix; then
      kernel_id=`strings /dynix | grep DYNIX`
    else
      kernel_id=
    fi
])dnl

  AC_CACHE_CHECK(OS release for uname, libc_cv_uname_release, [dnl
AC_REQUIRE([LIBC_KERNEL_ID])dnl
changequote(,)dnl
  kernel_release=`echo "$kernel_id" | sed 's/^[^0-9.]*\([0-9.]*\).*$/\1/'`
changequote([,])dnl
  if test x`echo "$config_release" | sed "s/^$kernel_release//"` \
	 != x$config_release; then
    # The configuration release is a substring of the kernel release.
    libc_cv_uname_release=$kernel_release
  elif test x$config_release != x; then
    libc_cv_uname_release=$config_release
  elif test x$kernel_release != x; then
    libc_cv_uname_release=$kernel_release
  else
    libc_cv_uname_release=unknown
  fi])
  uname_release="$libc_cv_uname_release"

  AC_CACHE_CHECK(OS version for uname, libc_cv_uname_version, [dnl
AC_REQUIRE([LIBC_KERNEL_ID])dnl
changequote(,)dnl
  kernel_version=`echo "$kernel_id" | sed 's/^[^#]*#\([0-9]*\).*$/\1/'`
changequote([,])dnl
  if test -n "$kernel_version"; then
    libc_cv_uname_version="$kernel_version"
  else
    libc_cv_uname_version=unknown
  fi])
  uname_version="$libc_cv_uname_version"

AC_SUBST(uname_sysname) AC_SUBST(uname_release) AC_SUBST(uname_version)dnl
  config_uname=config-name.h:config-name.in
else
  # For non-generic uname, we don't need to create config-name.h at all.
  config_uname=
fi

AC_MSG_CHECKING(stdio selection)
AC_SUBST(stdio)
case $stdio in
libio) AC_DEFINE(USE_IN_LIBIO) ;;
default) stdio=stdio ;;
esac
AC_MSG_RESULT($stdio)

AC_SUBST(libc_cv_slibdir)
AC_SUBST(libc_cv_sysconfdir)
AC_SUBST(libc_cv_rootsbindir)

AC_SUBST(has_ldconfig)

AC_SUBST(gnu_ld) AC_SUBST(gnu_as) AC_SUBST(elf)
if test $gnu_ld = yes; then
  AC_DEFINE(HAVE_GNU_LD)
fi
if test $gnu_as = yes; then
  AC_DEFINE(HAVE_GNU_AS)
fi
if test $elf = yes; then
  AC_DEFINE(HAVE_ELF)
fi

AC_SUBST(shared)
if test $shared = default; then
  if test $gnu_ld = yes; then
    shared=$elf
  else
    # For now we do not assume shared libs are available.  In future more
    # tests might become available.
    shared=no
  fi
fi
AC_SUBST(profile)
AC_SUBST(omitfp)
AC_SUBST(bounded)

AC_SUBST(DEFINES)

if test "`(cd $srcdir; pwd)`" = "`pwd`"; then
  config_makefile=
else
  config_makefile=Makefile
fi

VERSION=`sed -e 's/^#define VERSION "\([^"]*\)"/\1/p' -e d < $srcdir/version.h`
AC_SUBST(VERSION)

AC_OUTPUT(config.make glibcbug ${config_makefile} ${config_uname}, ,
          [echo '$config_vars' >> config.make])