gcc/configure.in

   1 # configure.in for GCC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5
   6 #This file is part of GCC.
   7
   8 #GCC is free software; you can redistribute it and/or modify it under
   9 #the terms of the GNU General Public License as published by the Free
  10 #Software Foundation; either version 2, or (at your option) any later
  11 #version.
  12
  13 #GCC is distributed in the hope that it will be useful, but WITHOUT
  14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 #for more details.
  17
  18 #You should have received a copy of the GNU General Public License
  19 #along with GCC; see the file COPYING.  If not, write to the Free
  20 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21 #02111-1307, USA.
  22
  23 # Initialization and defaults
  24 AC_PREREQ(2.13)
  25 AC_INIT(tree.c)
  26 AC_CONFIG_HEADER(auto-host.h:config.in)
  27
  28 remove=rm
  29 hard_link=ln
  30 symbolic_link='ln -s'
  31 copy=cp
  32
  33 # Check for bogus environment variables.
  34 # Test if LIBRARY_PATH contains the notation for the current directory
  35 # since this would lead to problems installing/building glibc.
  36 # LIBRARY_PATH contains the current directory if one of the following
  37 # is true:
  38 # - one of the terminals (":" and ";") is the first or last sign
  39 # - two terminals occur directly after each other
  40 # - the path contains an element with a dot in it
  41 AC_MSG_CHECKING(LIBRARY_PATH variable)
  42 changequote(,)dnl
  43 case ${LIBRARY_PATH} in
  44   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  45     library_path_setting="contains current directory"
  46     ;;
  47   *)
  48     library_path_setting="ok"
  49     ;;
  50 esac
  51 changequote([,])dnl
  52 AC_MSG_RESULT($library_path_setting)
  53 if test "$library_path_setting" != "ok"; then
  54 AC_MSG_ERROR([
  55 *** LIBRARY_PATH shouldn't contain the current directory when
  56 *** building gcc. Please change the environment variable
  57 *** and run configure again.])
  58 fi
  59
  60 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  61 # since this would lead to problems installing/building glibc.
  62 # GCC_EXEC_PREFIX contains the current directory if one of the following
  63 # is true:
  64 # - one of the terminals (":" and ";") is the first or last sign
  65 # - two terminals occur directly after each other
  66 # - the path contains an element with a dot in it
  67 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  68 changequote(,)dnl
  69 case ${GCC_EXEC_PREFIX} in
  70   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  71     gcc_exec_prefix_setting="contains current directory"
  72     ;;
  73   *)
  74     gcc_exec_prefix_setting="ok"
  75     ;;
  76 esac
  77 changequote([,])dnl
  78 AC_MSG_RESULT($gcc_exec_prefix_setting)
  79 if test "$gcc_exec_prefix_setting" != "ok"; then
  80 AC_MSG_ERROR([
  81 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  82 *** building gcc. Please change the environment variable
  83 *** and run configure again.])
  84 fi
  85
  86 # Check for additional parameters
  87
  88 # With GNU ld
  89 AC_ARG_WITH(gnu-ld,
  90 [  --with-gnu-ld           arrange to work with GNU ld.],
  91 gnu_ld_flag="$with_gnu_ld",
  92 gnu_ld_flag=no)
  93
  94 # With pre-defined ld
  95 AC_ARG_WITH(ld,
  96 [  --with-ld               arrange to use the specified ld (full pathname)],
  97 DEFAULT_LINKER="$with_ld")
  98 if test x"${DEFAULT_LINKER+set}" = x"set"; then
  99   if test ! -x "$DEFAULT_LINKER"; then
 100     AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 101   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 102     gnu_ld_flag=yes
 103   fi
 104   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 105         [Define to enable the use of a default linker.])
 106 fi
 107
 108 # With GNU as
 109 AC_ARG_WITH(gnu-as,
 110 [  --with-gnu-as           arrange to work with GNU as],
 111 gas_flag="$with_gnu_as",
 112 gas_flag=no)
 113
 114 AC_ARG_WITH(as,
 115 [  --with-as               arrange to use the specified as (full pathname)],
 116 DEFAULT_ASSEMBLER="$with_as")
 117 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 118   if test ! -x "$DEFAULT_ASSEMBLER"; then
 119     AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 120   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 121     gas_flag=yes
 122   fi
 123   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 124         [Define to enable the use of a default assembler.])
 125 fi
 126
 127 # With stabs
 128 AC_ARG_WITH(stabs,
 129 [  --with-stabs            arrange to use stabs instead of host debug format],
 130 stabs="$with_stabs",
 131 stabs=no)
 132
 133 # With ELF
 134 AC_ARG_WITH(elf,
 135 [  --with-elf              arrange to use ELF instead of host debug format],
 136 elf="$with_elf",
 137 elf=no)
 138
 139 # Specify the local prefix
 140 local_prefix=
 141 AC_ARG_WITH(local-prefix,
 142 [  --with-local-prefix=DIR specifies directory to put local include],
 143 [case "${withval}" in
 144 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 145 no)     ;;
 146 *)      local_prefix=$with_local_prefix ;;
 147 esac])
 148
 149 # Default local prefix if it is empty
 150 if test x$local_prefix = x; then
 151         local_prefix=/usr/local
 152 fi
 153
 154 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 155 # passed in by the toplevel make and thus we'd get different behavior
 156 # depending on where we built the sources.
 157 gcc_gxx_include_dir=
 158 # Specify the g++ header file directory
 159 AC_ARG_WITH(gxx-include-dir,
 160 [  --with-gxx-include-dir=DIR
 161                           specifies directory to put g++ header files],
 162 [case "${withval}" in
 163 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 164 no)     ;;
 165 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 166 esac])
 167
 168 if test x${gcc_gxx_include_dir} = x; then
 169   if test x${enable_version_specific_runtime_libs} = xyes; then
 170     gcc_gxx_include_dir='${libsubdir}/include/g++'
 171   else
 172     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 173 changequote(<<, >>)dnl
 174     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 175 changequote([, ])dnl
 176   fi
 177 fi
 178
 179 # Determine whether or not multilibs are enabled.
 180 AC_ARG_ENABLE(multilib,
 181 [  --enable-multilib       enable library support for multiple ABIs],
 182 [], [enable_multilib=yes])
 183 AC_SUBST(enable_multilib)
 184
 185 # Enable expensive internal checks
 186 AC_ARG_ENABLE(checking,
 187 [  --enable-checking[=LIST]
 188                           enable expensive run-time checks.  With LIST,
 189                           enable only specific categories of checks.
 190                           Categories are: misc,tree,rtl,rtlflag,gc,gcac;
 191                           default is misc,tree,gc,rtlflag],
 192 [ac_checking=
 193 ac_tree_checking=
 194 ac_rtl_checking=
 195 ac_rtlflag_checking=
 196 ac_gc_checking=
 197 ac_gc_always_collect=
 198 case "${enableval}" in
 199 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 200         ac_rtlflag_checking=1 ;;
 201 no)     ;;
 202 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 203         set fnord $enableval; shift
 204         IFS="$ac_save_IFS"
 205         for check
 206         do
 207                 case $check in
 208                 misc)   ac_checking=1 ;;
 209                 tree)   ac_tree_checking=1 ;;
 210                 rtlflag)        ac_rtlflag_checking=1 ;;
 211                 rtl)    ac_rtl_checking=1 ;;
 212                 gc)     ac_gc_checking=1 ;;
 213                 gcac)   ac_gc_always_collect=1 ;;
 214                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 215                 esac
 216         done
 217         ;;
 218 esac
 219 ],
 220 # Enable some checks by default for development versions of GCC
 221 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 222 if test x$ac_checking != x ; then
 223   AC_DEFINE(ENABLE_CHECKING, 1,
 224 [Define if you want more run-time sanity checks.  This one gets a grab
 225    bag of miscellaneous but relatively cheap checks.])
 226 fi
 227 if test x$ac_tree_checking != x ; then
 228   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 229 [Define if you want all operations on trees (the basic data
 230    structure of the front ends) to be checked for dynamic type safety
 231    at runtime.  This is moderately expensive.])
 232 fi
 233 if test x$ac_rtl_checking != x ; then
 234   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 235 [Define if you want all operations on RTL (the basic data structure
 236    of the optimizer and back end) to be checked for dynamic type safety
 237    at runtime.  This is quite expensive.])
 238 fi
 239 if test x$ac_rtlflag_checking != x ; then
 240   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 241 [Define if you want RTL flag accesses to be checked against the RTL
 242    codes that are supported for each access macro.  This is relatively
 243    cheap.])
 244 fi
 245 if test x$ac_gc_checking != x ; then
 246   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 247 [Define if you want the garbage collector to do object poisoning and
 248    other memory allocation checks.  This is quite expensive.])
 249 fi
 250 if test x$ac_gc_always_collect != x ; then
 251   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 252 [Define if you want the garbage collector to operate in maximally
 253    paranoid mode, validating the entire heap and collecting garbage at
 254    every opportunity.  This is extremely expensive.])
 255 fi
 256
 257 AC_ARG_WITH(cpp_install_dir,
 258 [  --with-cpp-install-dir=DIR
 259                           install the user visible C preprocessor in DIR
 260                           (relative to PREFIX) as well as PREFIX/bin],
 261 [if test x$withval = xyes; then
 262   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 263 elif test x$withval != xno; then
 264   cpp_install_dir=$withval
 265 fi])
 266
 267 # Enable __cxa_atexit for C++.
 268 AC_ARG_ENABLE(__cxa_atexit,
 269 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 270 [], [])
 271 if test x$enable___cxa_atexit = xyes; then
 272   AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
 273   [Define if you want to use __cxa_atexit, rather than atexit, to
 274    register C++ destructors for local statics and global objects.
 275    This is essential for fully standards-compliant handling of
 276    destructors, but requires __cxa_atexit in libc.])
 277 fi
 278
 279 # Enable Multibyte Characters for C/C++
 280 AC_ARG_ENABLE(c-mbchar,
 281 [  --enable-c-mbchar       enable multibyte characters for C and C++],
 282 if test x$enable_c_mbchar != xno; then
 283   AC_DEFINE(MULTIBYTE_CHARS, 1,
 284   [Define if you want the C and C++ compilers to support multibyte
 285    character sets for source code.])
 286 fi)
 287
 288 # Enable threads
 289 # Pass with no value to take the default
 290 # Pass with a value to specify a thread package
 291 AC_ARG_ENABLE(threads,
 292 [  --enable-threads        enable thread usage for target GCC
 293   --enable-threads=LIB    use LIB thread package for target GCC],,
 294 enable_threads='')
 295
 296 enable_threads_flag=$enable_threads
 297 # Check if a valid thread package
 298 case x${enable_threads_flag} in
 299         x | xno)
 300                 # No threads
 301                 target_thread_file='single'
 302                 ;;
 303         xyes)
 304                 # default
 305                 target_thread_file=''
 306                 ;;
 307         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
 308         xsolaris | xwin32 | xdce | xrtems| xvxworks | xaix)
 309                 target_thread_file=$enable_threads_flag
 310                 ;;
 311         *)
 312                 echo "$enable_threads is an unknown thread package" 1>&2
 313                 exit 1
 314                 ;;
 315 esac
 316
 317 AC_ARG_ENABLE(objc-gc,
 318 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 319                           the GNU Objective-C runtime],
 320 if test x$enable_objc_gc = xno; then
 321         objc_boehm_gc=''
 322 else
 323         objc_boehm_gc=1
 324 fi,
 325 objc_boehm_gc='')
 326
 327 AC_ARG_WITH(dwarf2,
 328 [  --with-dwarf2           force the default debug format to be DWARF 2],
 329 dwarf2="$with_dwarf2",
 330 dwarf2=no)
 331
 332 AC_ARG_ENABLE(shared,
 333 [  --disable-shared        don't provide a shared libgcc],
 334 [
 335   case $enable_shared in
 336   yes | no) ;;
 337   *)
 338     enable_shared=no
 339     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 340     for pkg in $enableval; do
 341       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 342         enable_shared=yes
 343       fi
 344     done
 345     IFS="$ac_save_ifs"
 346     ;;
 347   esac
 348 ], [enable_shared=yes])
 349 AC_SUBST(enable_shared)
 350
 351 # Determine the host, build, and target systems
 352 AC_CANONICAL_SYSTEM
 353
 354 # Set program_transform_name
 355 AC_ARG_PROGRAM
 356
 357 # Find the native compiler
 358 AC_PROG_CC
 359 AC_PROG_CC_C_O
 360 # autoconf is lame and doesn't give us any substitution variable for this.
 361 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 362   NO_MINUS_C_MINUS_O=yes
 363 else
 364   OUTPUT_OPTION='-o $@'
 365 fi
 366 AC_SUBST(NO_MINUS_C_MINUS_O)
 367 AC_SUBST(OUTPUT_OPTION)
 368
 369 # See if GNAT has been installed
 370 gcc_AC_PROG_GNAT
 371
 372 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
 373 ac_cv_prog_cc_no_long_long,
 374 [save_CFLAGS="$CFLAGS"
 375 CFLAGS="-Wno-long-long"
 376 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
 377                ac_cv_prog_cc_no_long_long=no)
 378 CFLAGS="$save_CFLAGS"])
 379
 380 if test x$have_gnat != xno ; then
 381 AC_CACHE_CHECK(whether ${ADAC} accepts -Wno-long-long,
 382 ac_cv_prog_adac_no_long_long,
 383 [cat >conftest.adb <<EOF
 384 procedure conftest is begin null; end conftest;
 385 EOF
 386 if $ADAC -Wno-long-long -c conftest.adb 1>&5 2>&5 ; then
 387   ac_cv_prog_adac_no_long_long=yes
 388 else
 389   ac_cv_prog_adac_no_long_long=no
 390 fi
 391 rm -f conftest*])
 392 else
 393   ac_cv_prog_adac_no_long_long=yes
 394 fi
 395
 396 strict1_warn=
 397 if test $ac_cv_prog_cc_no_long_long = yes && \
 398     test $ac_cv_prog_adac_no_long_long = yes ; then
 399   strict1_warn="-pedantic -Wno-long-long"
 400 fi
 401 AC_SUBST(strict1_warn)
 402
 403 AC_PROG_CPP
 404 AC_C_INLINE
 405 gcc_AC_C_VOLATILE
 406
 407 gcc_AC_C_LONG_DOUBLE
 408 gcc_AC_C_LONG_LONG
 409 gcc_AC_C__BOOL
 410
 411 # sizeof(char) is 1 by definition.
 412 gcc_AC_COMPILE_CHECK_SIZEOF(short)
 413 gcc_AC_COMPILE_CHECK_SIZEOF(int)
 414 gcc_AC_COMPILE_CHECK_SIZEOF(long)
 415 if test $ac_cv_c_long_long = yes; then
 416   gcc_AC_COMPILE_CHECK_SIZEOF(long long)
 417 fi
 418 if test $ac_cv_c___int64 = yes; then
 419   gcc_AC_COMPILE_CHECK_SIZEOF(__int64)
 420 fi
 421
 422 gcc_AC_C_CHARSET
 423
 424 # If the native compiler is GCC, we can enable warnings even in stage1.
 425 # That's useful for people building cross-compilers, or just running a
 426 # quick `make'.
 427 warn_cflags=
 428 if test "x$GCC" = "xyes"; then
 429   warn_cflags='$(GCC_WARN_CFLAGS)'
 430 fi
 431 AC_SUBST(warn_cflags)
 432
 433 # Stage specific cflags for build.
 434 stage1_cflags=
 435 case $build in
 436 vax-*-*)
 437   if test x$GCC = xyes
 438   then
 439     stage1_cflags="-Wa,-J"
 440   else
 441     stage1_cflags="-J"
 442   fi
 443   ;;
 444 powerpc-*-darwin*)
 445   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 446   # sources; use -no-cpp-precomp to get to GNU cpp.
 447   # Apple's GCC has bugs in designated initializer handling, so disable
 448   # that too.
 449   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 450   ;;
 451 esac
 452 AC_SUBST(stage1_cflags)
 453
 454 AC_PROG_MAKE_SET
 455
 456 AC_MSG_CHECKING([whether a default assembler was specified])
 457 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 458     if test x"$gas_flag" = x"no"; then
 459         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 460     else
 461         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 462     fi
 463 else
 464     AC_MSG_RESULT(no)
 465 fi
 466
 467 AC_MSG_CHECKING([whether a default linker was specified])
 468 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 469     if test x"$gnu_ld_flag" = x"no"; then
 470         AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 471     else
 472         AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 473     fi
 474 else
 475     AC_MSG_RESULT(no)
 476 fi
 477
 478 AC_MSG_CHECKING(for GNU C library)
 479 AC_CACHE_VAL(gcc_cv_glibc,
 480 [AC_TRY_COMPILE(
 481   [#include <features.h>],[
 482 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 483 #error Not a GNU C library system
 484 #endif],
 485   [gcc_cv_glibc=yes],
 486   gcc_cv_glibc=no)])
 487 AC_MSG_RESULT($gcc_cv_glibc)
 488 if test $gcc_cv_glibc = yes; then
 489   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 490 fi
 491
 492 # Find some useful tools
 493 AC_PROG_AWK
 494 gcc_AC_PROG_LN
 495 gcc_AC_PROG_LN_S
 496 AC_PROG_RANLIB
 497 gcc_AC_PROG_INSTALL
 498
 499 AC_HEADER_STDC
 500 AC_HEADER_TIME
 501 gcc_AC_HEADER_STDBOOL
 502 gcc_AC_HEADER_STRING
 503 AC_HEADER_SYS_WAIT
 504 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 505                  fcntl.h unistd.h sys/file.h sys/time.h \
 506                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 507                  direct.h malloc.h langinfo.h)
 508
 509 # Check for thread headers.
 510 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 511 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 512
 513 # These tests can't be done till we know if we have limits.h.
 514 gcc_AC_C_CHAR_BIT
 515 gcc_AC_C_COMPILE_ENDIAN
 516 gcc_AC_C_FLOAT_FORMAT
 517
 518 # See if we have the mktemp command.
 519 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 520
 521 # Do we have a single-tree copy of texinfo?
 522 if test -f $srcdir/../texinfo/Makefile.in; then
 523   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 524   gcc_cv_prog_makeinfo_modern=yes
 525   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 526 else
 527   # See if makeinfo has been installed and is modern enough
 528   # that we can use it.
 529   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 530   [GNU texinfo.* \([0-9][0-9.]*\)],
 531   [4.[1-9]*])
 532 fi
 533
 534 if test $gcc_cv_prog_makeinfo_modern = no; then
 535   AC_MSG_WARN([
 536 *** Makeinfo is missing or too old.
 537 *** Info documentation will not be built.])
 538   BUILD_INFO=
 539 else
 540   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 541 fi
 542
 543 # Is pod2man recent enough to regenerate manpages?
 544 AC_MSG_CHECKING([for recent Pod::Man])
 545 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 546   AC_MSG_RESULT(yes)
 547   GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
 548 else
 549   AC_MSG_RESULT(no)
 550   GENERATED_MANPAGES=
 551 fi
 552
 553 # How about lex?
 554 dnl Don't use AC_PROG_LEX; we insist on flex.
 555 dnl LEXLIB is not useful in gcc.
 556 if test -f $srcdir/../flex/skel.c; then
 557   FLEX='$(objdir)/../flex/flex'
 558 else
 559   AC_CHECK_PROG(FLEX, flex, flex, false)
 560 fi
 561
 562 # Bison?
 563 # The -L switch is so bison can find its skeleton file.
 564 if test -f $srcdir/../bison/bison.simple; then
 565   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 566 else
 567   AC_CHECK_PROG(BISON, bison, bison, false)
 568 fi
 569
 570 # These libraries may be used by collect2.
 571 # We may need a special search path to get them linked.
 572 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 573 [save_LIBS="$LIBS"
 574 for libs in '' -lld -lmld \
 575                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 576                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 577 do
 578         LIBS="$libs"
 579         AC_TRY_LINK_FUNC(ldopen,
 580                 [gcc_cv_collect2_libs="$libs"; break])
 581 done
 582 LIBS="$save_LIBS"
 583 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 584 case $gcc_cv_collect2_libs in
 585         "none required")        ;;
 586         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 587 esac
 588 AC_SUBST(COLLECT2_LIBS)
 589
 590 # When building Ada code on Alpha, we need exc_resume which is usually in
 591 # -lexc.  So test for it.
 592 save_LIBS="$LIBS"
 593 LIBS=
 594 AC_SEARCH_LIBS(exc_resume, exc)
 595 GNAT_LIBEXC="$LIBS"
 596 LIBS="$save_LIBS"
 597 AC_SUBST(GNAT_LIBEXC)
 598
 599 # See if the stage1 system preprocessor understands the ANSI C
 600 # preprocessor stringification operator.  (Used by symcat.h.)
 601 AC_C_STRINGIZE
 602
 603 # Use <inttypes.h> only if it exists,
 604 # doesn't clash with <sys/types.h>, and declares intmax_t.
 605 AC_MSG_CHECKING(for inttypes.h)
 606 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 607 [AC_TRY_COMPILE(
 608   [#include <sys/types.h>
 609 #include <inttypes.h>],
 610   [intmax_t i = -1;],
 611   [gcc_cv_header_inttypes_h=yes],
 612   gcc_cv_header_inttypes_h=no)])
 613 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 614 if test $gcc_cv_header_inttypes_h = yes; then
 615   AC_DEFINE(HAVE_INTTYPES_H, 1,
 616         [Define if you have a working <inttypes.h> header file.])
 617 fi
 618
 619 dnl Disabled until we have a complete test for buggy enum bitfields.
 620 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 621
 622 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 623         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 624         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat \
 625         scandir alphasort)
 626
 627 AC_CHECK_TYPE(ssize_t, int)
 628
 629 # Try to determine the array type of the second argument of getgroups
 630 # for the target system (int or gid_t).
 631 AC_TYPE_GETGROUPS
 632 if test "${target}" = "${build}"; then
 633   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 634 else
 635   case "${target}" in
 636         # This condition may need some tweaking.  It should include all
 637         # targets where the array type of the second argument of getgroups
 638         # is int and the type of gid_t is not equivalent to int.
 639         *-*-sunos* | *-*-ultrix*)
 640                 TARGET_GETGROUPS_T=int
 641                 ;;
 642         *)
 643                 TARGET_GETGROUPS_T=gid_t
 644                 ;;
 645   esac
 646 fi
 647 AC_SUBST(TARGET_GETGROUPS_T)
 648
 649 gcc_AC_FUNC_PRINTF_PTR
 650
 651 case "${host}" in
 652 *-*-uwin*)
 653   AC_MSG_ERROR([
 654 *** UWIN may not be used as a host platform because
 655 *** linking with posix.dll is not allowed by the GNU GPL])
 656   ;;
 657 *-*-*vms*)
 658   # Under VMS, vfork works very different than on Unix. The standard test
 659   # won't work, and it isn't easily adaptable. It makes more sense to
 660   # just force it.
 661   ac_cv_func_vfork_works=yes
 662   ;;
 663 esac
 664 AC_FUNC_VFORK
 665 AC_FUNC_MMAP_ANYWHERE
 666 AC_FUNC_MMAP_FILE
 667
 668 AM_ICONV
 669
 670 # We will need to find libiberty.h and ansidecl.h
 671 saved_CFLAGS="$CFLAGS"
 672 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 673 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 674         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
 675         fprintf_unlocked strstr errno \
 676         malloc realloc calloc free basename getopt clock, , ,[
 677 #include "ansidecl.h"
 678 #include "system.h"])
 679
 680 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 681 #include "ansidecl.h"
 682 #include "system.h"
 683 #ifdef HAVE_SYS_RESOURCE_H
 684 #include <sys/resource.h>
 685 #endif
 686 ])
 687
 688 gcc_AC_CHECK_DECLS(times, , ,[
 689 #include "ansidecl.h"
 690 #include "system.h"
 691 #ifdef HAVE_SYS_TIMES_H
 692 #include <sys/times.h>
 693 #endif
 694 ])
 695
 696 # More time-related stuff.
 697 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
 698 AC_TRY_COMPILE([
 699 #include "ansidecl.h"
 700 #include "system.h"
 701 #ifdef HAVE_SYS_TIMES_H
 702 #include <sys/times.h>
 703 #endif
 704 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
 705 if test $ac_cv_struct_tms = yes; then
 706   AC_DEFINE(HAVE_STRUCT_TMS, 1,
 707   [Define if <sys/times.h> defines struct tms.])
 708 fi
 709
 710 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
 711 # revisit after autoconf 2.50.
 712 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
 713 AC_TRY_COMPILE([
 714 #include "ansidecl.h"
 715 #include "system.h"
 716 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
 717 if test $gcc_cv_type_clock_t = yes; then
 718   AC_DEFINE(HAVE_CLOCK_T, 1,
 719   [Define if <time.h> defines clock_t.])
 720 fi
 721
 722 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 723 CFLAGS="$saved_CFLAGS"
 724
 725 # mkdir takes a single argument on some systems.
 726 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 727
 728 # File extensions
 729 manext='.1'
 730 objext='.o'
 731 AC_SUBST(manext)
 732 AC_SUBST(objext)
 733
 734 config_gtfiles=
 735 build_xm_file=
 736 build_xm_defines=
 737 build_install_headers_dir=install-headers-tar
 738 build_exeext=
 739 host_xm_file=
 740 host_xm_defines=
 741 host_xmake_file=
 742 host_truncate_target=
 743 host_exeext=
 744
 745 # Decode the host machine, then the target machine.
 746 # For the host machine, we save the xm_file variable as host_xm_file;
 747 # then we decode the target machine and forget everything else
 748 # that came from the host machine.
 749 for machine in $build $host $target; do
 750         . ${srcdir}/config.gcc
 751 done
 752
 753 extra_objs="${host_extra_objs} ${extra_objs}"
 754
 755 # Default the target-machine variables that were not explicitly set.
 756 if test x"$tm_file" = x
 757 then tm_file=$cpu_type/$cpu_type.h; fi
 758
 759 if test x"$extra_headers" = x
 760 then extra_headers=; fi
 761
 762 if test x$md_file = x
 763 then md_file=$cpu_type/$cpu_type.md; fi
 764
 765 if test x$out_file = x
 766 then out_file=$cpu_type/$cpu_type.c; fi
 767
 768 if test x"$tmake_file" = x
 769 then tmake_file=$cpu_type/t-$cpu_type
 770 fi
 771
 772 if test x"$dwarf2" = xyes
 773 then tm_file="$tm_file tm-dwarf2.h"
 774 fi
 775
 776 if test x$float_format = x
 777 then float_format=i64
 778 fi
 779
 780 if test $float_format = none
 781 then float_h_file=Makefile.in
 782 else float_h_file=float-$float_format.h
 783 fi
 784
 785 # Say what files are being used for the output code and MD file.
 786 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
 787 echo "Using \`$srcdir/config/$md_file' as machine description file."
 788
 789 # If any of the xm_file variables contain nonexistent files, warn
 790 # about them and drop them.
 791
 792 bx=
 793 for x in $build_xm_file; do
 794   if    test -f $srcdir/config/$x
 795   then      bx="$bx $x"
 796   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 797   fi
 798 done
 799 build_xm_file="$bx"
 800
 801 hx=
 802 for x in $host_xm_file; do
 803   if    test -f $srcdir/config/$x
 804   then      hx="$hx $x"
 805   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 806   fi
 807 done
 808 host_xm_file="$hx"
 809
 810 tx=
 811 for x in $xm_file; do
 812   if    test -f $srcdir/config/$x
 813   then      tx="$tx $x"
 814   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 815   fi
 816 done
 817 xm_file="$tx"
 818
 819 count=a
 820 for f in $tm_file; do
 821         count=${count}x
 822 done
 823 if test $count = ax; then
 824         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
 825 else
 826         echo "Using the following target machine macro files:"
 827         for f in $tm_file; do
 828                 echo "  $srcdir/config/$f"
 829         done
 830 fi
 831
 832 count=a
 833 for f in $host_xm_file; do
 834         count=${count}x
 835 done
 836 if test $count = a; then
 837         :
 838 elif test $count = ax; then
 839         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
 840 else
 841         echo "Using the following host machine macro files:"
 842         for f in $host_xm_file; do
 843                 echo "  $srcdir/config/$f"
 844         done
 845 fi
 846
 847 if test "$host_xm_file" != "$build_xm_file"; then
 848         count=a
 849         for f in $build_xm_file; do
 850                 count=${count}x
 851         done
 852         if test $count = a; then
 853                 :
 854         elif test $count = ax; then
 855                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
 856         else
 857                 echo "Using the following build machine macro files:"
 858                 for f in $build_xm_file; do
 859                         echo "  $srcdir/config/$f"
 860                 done
 861         fi
 862 fi
 863
 864 if test x$thread_file = x; then
 865         if test x$target_thread_file != x; then
 866                 thread_file=$target_thread_file
 867         else
 868                 thread_file='single'
 869         fi
 870 fi
 871
 872 # Look for a file containing extra machine modes.
 873 if test -f $srcdir/config/${cpu_type}/${cpu_type}-modes.def; then
 874   extra_modes_file='$(srcdir)/config/'${cpu_type}/${cpu_type}-modes.def
 875   AC_SUBST(extra_modes_file)
 876   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE,
 877                            "${cpu_type}/${cpu_type}-modes.def",
 878   [Define to the name of a file containing a list of extra machine modes
 879    for this architecture.])
 880   AC_DEFINE(EXTRA_CC_MODES, 1,
 881   [Define if the target architecture needs extra machine modes to represent
 882    the results of comparisons.])
 883 fi
 884
 885 # auto-host.h is the file containing items generated by autoconf and is
 886 # the first file included by config.h.
 887 # If host=build, it is correct to have hconfig include auto-host.h
 888 # as well.  If host!=build, we are in error and need to do more
 889 # work to find out the build config parameters.
 890 if test x$host = x$build
 891 then
 892         build_auto=auto-host.h
 893         FORBUILD=..
 894 else
 895         # We create a subdir, then run autoconf in the subdir.
 896         # To prevent recursion we set host and build for the new
 897         # invocation of configure to the build for this invocation
 898         # of configure.
 899         tempdir=build.$$
 900         rm -rf $tempdir
 901         mkdir $tempdir
 902         cd $tempdir
 903         case ${srcdir} in
 904         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
 905         *) realsrcdir=../${srcdir};;
 906         esac
 907         saved_CFLAGS="${CFLAGS}"
 908         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
 909         ${realsrcdir}/configure \
 910                 --target=$target_alias --host=$build_alias --build=$build_alias
 911         CFLAGS="${saved_CFLAGS}"
 912
 913         # We just finished tests for the build machine, so rename
 914         # the file auto-build.h in the gcc directory.
 915         mv auto-host.h ../auto-build.h
 916         cd ..
 917         rm -rf $tempdir
 918         build_auto=auto-build.h
 919         FORBUILD=../$build
 920 fi
 921 AC_SUBST(FORBUILD)
 922
 923 tm_file="${tm_file} defaults.h"
 924 host_xm_file="auto-host.h ansidecl.h ${host_xm_file} ${tm_file}"
 925 build_xm_file="${build_auto} ansidecl.h ${build_xm_file} ${tm_file}"
 926 xm_file="ansidecl.h ${xm_file} ${tm_file}"
 927
 928 # Truncate the target if necessary
 929 if test x$host_truncate_target != x; then
 930         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
 931 fi
 932
 933 # Get the version trigger filename from the toplevel
 934 if test "${with_gcc_version_trigger+set}" = set; then
 935         gcc_version_trigger=$with_gcc_version_trigger
 936 else
 937         gcc_version_trigger=${srcdir}/version.c
 938 fi
 939 changequote(,)dnl
 940 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
 941 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
 942
 943 # Compile in configure arguments.
 944 if test -f configargs.h ; then
 945         # Being re-configured.
 946         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
 947         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
 948 else
 949         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
 950 fi
 951 cat > configargs.h <<EOF
 952 /* Generated automatically. */
 953 static const char configuration_arguments[] = "$gcc_config_arguments";
 954 static const char thread_model[] = "$thread_file";
 955 EOF
 956 changequote([,])dnl
 957
 958 # Internationalization
 959 PACKAGE=gcc
 960 VERSION="$gcc_version"
 961 AC_SUBST(PACKAGE)
 962 AC_SUBST(VERSION)
 963
 964 # Enable NLS support by default
 965 AC_ARG_ENABLE(nls,
 966   [  --enable-nls            use Native Language Support (default)],
 967   , enable_nls=yes)
 968
 969 # if cross compiling, disable NLS support.
 970 # It's not worth the trouble, at least for now.
 971
 972 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
 973   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
 974   enable_nls=no
 975 fi
 976
 977 AM_GNU_GETTEXT
 978
 979 # Windows32 Registry support for specifying GCC installation paths.
 980 AC_ARG_ENABLE(win32-registry,
 981 [  --disable-win32-registry
 982                           disable lookup of installation paths in the
 983                           Registry on Windows hosts
 984   --enable-win32-registry enable registry lookup (default)
 985   --enable-win32-registry=KEY
 986                           use KEY instead of GCC version as the last portion
 987                           of the registry key],,)
 988 case $host_os in
 989         win32 | pe | cygwin* | mingw32* | uwin*)
 990 AC_MSG_CHECKING(whether windows registry support is requested)
 991 if test "x$enable_win32_registry" != xno; then
 992   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
 993 [Define to 1 if installation paths should be looked up in Windows32
 994    Registry. Ignored on non windows32 hosts.])
 995   AC_MSG_RESULT(yes)
 996   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
 997 else
 998   AC_MSG_RESULT(no)
 999 fi
1000
1001 # Check if user specified a different registry key.
1002 case "x${enable_win32_registry}" in
1003 x | xyes)
1004   # default.
1005   gcc_cv_win32_registry_key="$VERSION"
1006   ;;
1007 xno)
1008   # no registry lookup.
1009   gcc_cv_win32_registry_key=''
1010   ;;
1011 *)
1012   # user-specified key.
1013   gcc_cv_win32_registry_key="$enable_win32_registry"
1014   ;;
1015 esac
1016
1017 if test "x$enable_win32_registry" != xno; then
1018   AC_MSG_CHECKING(registry key on windows hosts)
1019   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1020         [Define to be the last portion of registry key on windows hosts.])
1021   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1022 fi
1023 ;;
1024 esac
1025
1026 # Get an absolute path to the GCC top-level source directory
1027 holddir=`${PWDCMD-pwd}`
1028 cd $srcdir
1029 topdir=`${PWDCMD-pwd}`
1030 cd $holddir
1031
1032 # Conditionalize the makefile for this host machine.
1033 # Make-host contains the concatenation of all host makefile fragments
1034 # [there can be more than one].  This file is built by configure.frag.
1035 host_overrides=Make-host
1036 dep_host_xmake_file=
1037 for f in .. ${host_xmake_file}
1038 do
1039         if test -f ${srcdir}/config/$f
1040         then
1041                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1042         fi
1043 done
1044
1045 # Conditionalize the makefile for this target machine.
1046 # Make-target contains the concatenation of all host makefile fragments
1047 # [there can be more than one].  This file is built by configure.frag.
1048 target_overrides=Make-target
1049 dep_tmake_file=
1050 for f in .. ${tmake_file}
1051 do
1052         if test -f ${srcdir}/config/$f
1053         then
1054                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1055         fi
1056 done
1057
1058 # If the host doesn't support symlinks, modify CC in
1059 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1060 # Otherwise, we can use "CC=$(CC)".
1061 rm -f symtest.tem
1062 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1063 then
1064         cc_set_by_configure="\$(CC)"
1065         quoted_cc_set_by_configure="\$(CC)"
1066         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1067         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1068 else
1069         rm -f symtest.tem
1070         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1071         then
1072                 symbolic_link="cp -p"
1073         else
1074                 symbolic_link="cp"
1075         fi
1076         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1077         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1078         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1079         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1080 fi
1081 rm -f symtest.tem
1082
1083 out_object_file=`basename $out_file .c`.o
1084
1085 tm_file_list=
1086 for f in $tm_file; do
1087   case $f in
1088     ansidecl.h )
1089        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1090     defaults.h )
1091        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1092     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1093   esac
1094 done
1095
1096 tm_p_file_list=
1097 for f in $tm_p_file; do
1098     tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1099 done
1100
1101 host_xm_file_list=
1102 for f in $host_xm_file; do
1103   case $f in
1104     ansidecl.h )
1105        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1106     auto-host.h )
1107        host_xm_file_list="${host_xm_file_list} $f" ;;
1108     defaults.h )
1109        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1110     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1111   esac
1112 done
1113
1114 build_xm_file_list=
1115 for f in $build_xm_file; do
1116   case $f in
1117     ansidecl.h )
1118        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1119     auto-build.h | auto-host.h )
1120        build_xm_file_list="${build_xm_file_list} $f" ;;
1121     defaults.h )
1122        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1123     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1124   esac
1125 done
1126
1127 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1128 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1129 CROSS=                                          AC_SUBST(CROSS)
1130 ALL=all.internal                                AC_SUBST(ALL)
1131 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1132 if test x$host != x$target
1133 then
1134         CROSS="-DCROSS_COMPILE"
1135         ALL=all.cross
1136         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1137         case "$host","$target" in
1138             i?86-*-*,x86_64-*-* \
1139             | powerpc*-*-*,powerpc64*-*-*)
1140                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1141         esac
1142 fi
1143
1144 # If this is a cross-compiler that does not
1145 # have its own set of headers then define
1146 # inhibit_libc
1147
1148 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1149 # This prevents libgcc2 from containing any code which requires libc
1150 # support.
1151 inhibit_libc=
1152 if [test x$host != x$target] && [test x$with_headers = x]; then
1153        inhibit_libc=-Dinhibit_libc
1154 else
1155        if [test x$with_newlib = xyes]; then
1156                inhibit_libc=-Dinhibit_libc
1157        fi
1158 fi
1159 AC_SUBST(inhibit_libc)
1160
1161 # When building gcc with a cross-compiler, we need to adjust things so
1162 # that the generator programs are still built with the native compiler.
1163 # Also, we cannot run fixincludes or fix-header.
1164 # Note that the terminology here is wrong; it should be BUILD_* throughout.
1165 # FIXME.
1166
1167 # These are the normal (build=host) settings:
1168 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1169 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1170 HOST_CC='$(CC)'                 AC_SUBST(HOST_CC)
1171 HOST_CFLAGS='$(ALL_CFLAGS)'     AC_SUBST(HOST_CFLAGS)
1172
1173 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1174 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1175
1176 # And these apply if build != host.
1177 if test x$build != x$host
1178 then
1179     BUILD_PREFIX=build-
1180     BUILD_PREFIX_1=build-
1181     HOST_CC='$(CC_FOR_BUILD)'
1182     HOST_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1183
1184     STMP_FIXINC=
1185     STMP_FIXPROTO=
1186 fi
1187
1188 # Expand extra_headers to include complete path.
1189 # This substitutes for lots of t-* files.
1190 extra_headers_list=
1191 if test "x$extra_headers" = x
1192 then true
1193 else
1194         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1195         for file in $extra_headers;
1196         do
1197                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1198         done
1199 fi
1200
1201 if test x$use_collect2 = xno; then
1202         use_collect2=
1203 fi
1204
1205 # Add a definition of USE_COLLECT2 if system wants one.
1206 if test x$use_collect2 != x
1207 then
1208         host_xm_defines="${host_xm_defines} USE_COLLECT2"
1209         xm_defines="${xm_defines} USE_COLLECT2"
1210 fi
1211
1212 # If we have gas in the build tree, make a link to it.
1213 if test -f ../gas/Makefile; then
1214         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1215 fi
1216
1217 # If we have nm and objdump in the build tree, make a link to them.
1218 if test -f ../binutils/Makefile; then
1219         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1220         rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
1221 fi
1222
1223 # If we have ld in the build tree, make a link to it.
1224 if test -f ../ld/Makefile; then
1225         rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1226 fi
1227
1228 # Figure out what assembler we will be using.
1229 AC_MSG_CHECKING(what assembler to use)
1230 gcc_cv_as=
1231 gcc_cv_gas_major_version=
1232 gcc_cv_gas_minor_version=
1233 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1234 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1235 if test -x "$DEFAULT_ASSEMBLER"; then
1236         gcc_cv_as="$DEFAULT_ASSEMBLER"
1237 elif test -x "$AS"; then
1238         gcc_cv_as="$AS"
1239 elif test -x as$host_exeext; then
1240         # Build using assembler in the current directory.
1241         gcc_cv_as=./as$host_exeext
1242 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1243         # Single tree build which includes gas.
1244         for f in $gcc_cv_as_bfd_srcdir/configure $gcc_cv_as_gas_srcdir/configure $gcc_cv_as_gas_srcdir/configure.in $gcc_cv_as_gas_srcdir/Makefile.in
1245         do
1246 changequote(,)dnl
1247                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1248 changequote([,])dnl
1249                 if test x$gcc_cv_gas_version != x; then
1250                         break
1251                 fi
1252         done
1253 changequote(,)dnl
1254         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1255         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1256         gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"`
1257 changequote([,])dnl
1258 fi
1259
1260 if test "x$gcc_cv_as" = x; then
1261         # Search the same directories that the installed compiler will
1262         # search.  Else we may find the wrong assembler and lose.  If we
1263         # do not find a suitable assembler binary, then try the user's
1264         # path.
1265         #
1266         # Also note we have to check MD_EXEC_PREFIX before checking the
1267         # user's path.  Unfortunately, there is no good way to get at the
1268         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1269         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1270         # to be fixed as part of the make/configure rewrite too.
1271
1272         if test "x$exec_prefix" = xNONE; then
1273                 if test "x$prefix" = xNONE; then
1274                         test_prefix=/usr/local
1275                 else
1276                         test_prefix=$prefix
1277                 fi
1278         else
1279                 test_prefix=$exec_prefix
1280         fi
1281
1282         # If the loop below does not find an assembler, then use whatever
1283         # one we can find in the users's path.
1284         # user's path.
1285         if test "x$program_prefix" != xNONE; then
1286                 gcc_cv_as=${program_prefix}as$host_exeext
1287         else
1288                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1289         fi
1290
1291         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1292                    $test_prefix/lib/gcc-lib/$target_alias \
1293                    /usr/lib/gcc/$target_alias/$gcc_version \
1294                    /usr/lib/gcc/$target_alias \
1295                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1296                    $test_prefix/$target_alias/bin"
1297
1298         if test x$host = x$target; then
1299             test_dirs="$test_dirs \
1300                    /usr/libexec \
1301                    /usr/ccs/gcc \
1302                    /usr/ccs/bin \
1303                    /udk/usr/ccs/bin \
1304                    /bsd43/usr/lib/cmplrs/cc \
1305                    /usr/cross64/usr/bin \
1306                    /usr/lib/cmplrs/cc \
1307                    /sysv/usr/lib/cmplrs/cc \
1308                    /svr4/usr/lib/cmplrs/cc \
1309                    /usr/bin"
1310         fi
1311
1312         for dir in $test_dirs; do
1313                 if test -x $dir/as$host_exeext; then
1314                         gcc_cv_as=$dir/as$host_exeext
1315                         break;
1316                 fi
1317         done
1318 fi
1319 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1320   AC_MSG_RESULT("newly built gas")
1321 else
1322   AC_MSG_RESULT($gcc_cv_as)
1323 fi
1324
1325 # Figure out what linker we will be using.
1326 AC_MSG_CHECKING(what linker to use)
1327 gcc_cv_ld=
1328 gcc_cv_gld_major_version=
1329 gcc_cv_gld_minor_version=
1330 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1331 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1332 if test -x "$DEFAULT_LINKER"; then
1333         gcc_cv_ld="$DEFAULT_LINKER"
1334 elif test -x "$LD"; then
1335         gcc_cv_ld="$LD"
1336 elif test -x ld$host_exeext; then
1337         # Build using linker in the current directory.
1338         gcc_cv_ld=./ld$host_exeext
1339 elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
1340         # Single tree build which includes ld.
1341         for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
1342         do
1343 changequote(,)dnl
1344                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1345 changequote([,])dnl
1346                 if test x$gcc_cv_gld_version != x; then
1347                         break
1348                 fi
1349         done
1350 changequote(,)dnl
1351         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1352         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1353 changequote([,])dnl
1354 fi
1355
1356 if test "x$gcc_cv_ld" = x; then
1357         # Search the same directories that the installed compiler will
1358         # search.  Else we may find the wrong linker and lose.  If we
1359         # do not find a suitable linker binary, then try the user's
1360         # path.
1361         #
1362         # Also note we have to check MD_EXEC_PREFIX before checking the
1363         # user's path.  Unfortunately, there is no good way to get at the
1364         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1365         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1366         # to be fixed as part of the make/configure rewrite too.
1367
1368         if test "x$exec_prefix" = xNONE; then
1369                 if test "x$prefix" = xNONE; then
1370                         test_prefix=/usr/local
1371                 else
1372                         test_prefix=$prefix
1373                 fi
1374         else
1375                 test_prefix=$exec_prefix
1376         fi
1377
1378         # If the loop below does not find an linker, then use whatever
1379         # one we can find in the users's path.
1380         # user's path.
1381         if test "x$program_prefix" != xNONE; then
1382                 gcc_cv_ld=${program_prefix}ld$host_exeext
1383         else
1384                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1385         fi
1386
1387         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1388                    $test_prefix/lib/gcc-lib/$target_alias \
1389                    /usr/lib/gcc/$target_alias/$gcc_version \
1390                    /usr/lib/gcc/$target_alias \
1391                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1392                    $test_prefix/$target_alias/bin"
1393
1394         if test x$host = x$target; then
1395             test_dirs="$test_dirs \
1396                    /usr/libexec \
1397                    /usr/ccs/gcc \
1398                    /usr/ccs/bin \
1399                    /udk/usr/ccs/bin \
1400                    /bsd43/usr/lib/cmplrs/cc \
1401                    /usr/cross64/usr/bin \
1402                    /usr/lib/cmplrs/cc \
1403                    /sysv/usr/lib/cmplrs/cc \
1404                    /svr4/usr/lib/cmplrs/cc \
1405                    /usr/bin"
1406         fi
1407
1408         for dir in $test_dirs; do
1409                 if test -x $dir/ld$host_exeext; then
1410                         gcc_cv_ld=$dir/ld$host_exeext
1411                         break;
1412                 fi
1413         done
1414 fi
1415 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
1416   AC_MSG_RESULT("newly built ld")
1417 else
1418   AC_MSG_RESULT($gcc_cv_ld)
1419 fi
1420
1421 # Figure out what nm we will be using.
1422 AC_MSG_CHECKING(what nm to use)
1423 if test -x nm$host_exeext; then
1424         gcc_cv_nm=./nm$host_exeext
1425 elif test "x$program_prefix" != xNONE; then
1426         gcc_cv_nm=${program_prefix}nm$host_exeext
1427 else
1428         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1429 fi
1430 AC_MSG_RESULT($gcc_cv_nm)
1431
1432 # Figure out what objdump we will be using.
1433 AC_MSG_CHECKING(what objdump to use)
1434 if test -x objdump$host_exeext; then
1435         gcc_cv_objdump=./objdump$host_exeext
1436 elif test "x$program_prefix" != xNONE; then
1437         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1438 else
1439         gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
1440 fi
1441 AC_MSG_RESULT($gcc_cv_objdump)
1442
1443 # Figure out what assembler alignment features are present.
1444 AC_MSG_CHECKING(assembler alignment features)
1445 gcc_cv_as_alignment_features=none
1446 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1447         # Gas version 2.6 and later support for .balign and .p2align.
1448         # bytes to skip when using .p2align.
1449         if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 6 -o "$gcc_cv_gas_major_version" -gt 2; then
1450                 gcc_cv_as_alignment_features=".balign and .p2align"
1451                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1452         fi
1453         # Gas version 2.8 and later support specifying the maximum
1454         # bytes to skip when using .p2align.
1455         if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 8 -o "$gcc_cv_gas_major_version" -gt 2; then
1456                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1457                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1458         fi
1459 elif test x$gcc_cv_as != x; then
1460         # Check if we have .balign and .p2align
1461         echo ".balign  4" > conftest.s
1462         echo ".p2align  2" >> conftest.s
1463         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1464                 gcc_cv_as_alignment_features=".balign and .p2align"
1465                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1466         fi
1467         rm -f conftest.s conftest.o
1468         # Check if specifying the maximum bytes to skip when
1469         # using .p2align is supported.
1470         echo ".p2align 4,,7" > conftest.s
1471         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1472                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1473                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1474         fi
1475         rm -f conftest.s conftest.o
1476 fi
1477 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1478
1479 AC_MSG_CHECKING(assembler subsection support)
1480 gcc_cv_as_subsections=no
1481 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1482   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1483     gcc_cv_as_subsections="working .subsection -1"
1484   fi
1485 elif test x$gcc_cv_as != x; then
1486         # Check if we have .subsection
1487         echo ".subsection 1" > conftest.s
1488         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1489                 gcc_cv_as_subsections=".subsection"
1490                 if test x$gcc_cv_nm != x; then
1491                         cat > conftest.s <<EOF
1492 conftest_label1: .word 0
1493 .subsection -1
1494 conftest_label2: .word 0
1495 .previous
1496 EOF
1497                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1498                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1499                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1500                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1501                                         :
1502                                 else
1503                                         gcc_cv_as_subsections="working .subsection -1"
1504                                 fi
1505                         fi
1506                 fi
1507         fi
1508         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1509 fi
1510 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1511         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1512 [Define if your assembler supports .subsection and .subsection -1 starts
1513    emitting at the beginning of your section.])
1514 fi
1515 AC_MSG_RESULT($gcc_cv_as_subsections)
1516
1517 AC_MSG_CHECKING(assembler weak support)
1518 gcc_cv_as_weak=no
1519 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1520   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 2 -o "$gcc_cv_gas_major_version" -gt 2; then
1521     gcc_cv_as_weak="yes"
1522   fi
1523 elif test x$gcc_cv_as != x; then
1524         # Check if we have .weak
1525         echo "  .weak foobar" > conftest.s
1526         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1527                 gcc_cv_as_weak="yes"
1528         fi
1529         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1530 fi
1531 if test x"$gcc_cv_as_weak" = xyes; then
1532         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1533 fi
1534 AC_MSG_RESULT($gcc_cv_as_weak)
1535
1536 AC_MSG_CHECKING(assembler hidden support)
1537 gcc_cv_as_hidden=no
1538 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1539   if test "$gcc_cv_gas_major_version" -eq 2     \
1540           -a "$gcc_cv_gas_minor_version" -eq 12 \
1541           -a "$gcc_cv_gas_patch_version" -ge 1  \
1542           -o "$gcc_cv_gas_major_version" -eq 2  \
1543           -a "$gcc_cv_gas_minor_version" -gt 12 \
1544           -o "$gcc_cv_gas_major_version" -gt 2  \
1545     && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1546     gcc_cv_as_hidden="yes"
1547   fi
1548 elif test x$gcc_cv_as != x; then
1549         # Check if we have .hidden
1550         echo "  .hidden foobar" > conftest.s
1551         echo "foobar:" >> conftest.s
1552         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1553                 gcc_cv_as_hidden="yes"
1554         fi
1555         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1556
1557         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1558         # This is irritatingly difficult to feature test for.  Look for
1559         # the date string after the version number.
1560         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1561         if echo "$ld_ver" | grep GNU > /dev/null; then
1562 changequote(,)dnl
1563                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1564                 ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'`
1565                 if test 0"$ld_date" -lt 20020404; then
1566                         if test -n "$ld_date"; then
1567                                 # If there was date string, but was earlier than 2002-04-04, fail
1568                                 gcc_cv_as_hidden="no"
1569                         elif test -z "$ld_vers"; then
1570                                 # If there was no date string nor ld version number, something is wrong
1571                                 gcc_cv_as_hidden="no"
1572                         else
1573                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1574                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1575                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1576                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1577                                 if test "$ld_vers_major" -lt 2; then
1578                                         gcc_cv_as_hidden="no"
1579                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1580                                         gcc_cv_as_hidden="no"
1581                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1582                                           -a "$ld_vers_patch" -eq 0; then
1583                                         gcc_cv_as_hidden="no"
1584                                 fi
1585                         fi
1586                 fi
1587 changequote([,])dnl
1588         fi
1589 fi
1590 if test x"$gcc_cv_as_hidden" = xyes; then
1591         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1592                 [Define if your assembler supports .hidden.])
1593 fi
1594 AC_MSG_RESULT($gcc_cv_as_hidden)
1595 libgcc_visibility=$gcc_cv_as_hidden
1596 AC_SUBST(libgcc_visibility)
1597
1598 AC_MSG_CHECKING(assembler leb128 support)
1599 gcc_cv_as_leb128=no
1600 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1601   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 11 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1602     gcc_cv_as_leb128="yes"
1603   fi
1604 elif test x$gcc_cv_as != x; then
1605         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1606         cat > conftest.s <<EOF
1607         .data
1608         .uleb128 L2 - L1
1609 L1:
1610         .uleb128 1280
1611         .sleb128 -1010
1612 L2:
1613 EOF
1614         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1615                 gcc_cv_as_leb128="yes"
1616
1617                 # GAS versions before 2.11 do not support uleb128,
1618                 # despite appearing to.
1619                 # ??? There exists an elf-specific test that will crash
1620                 # the assembler.  Perhaps it's better to figure out whether
1621                 # arbitrary sections are supported and try the test.
1622                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1623                 if echo "$as_ver" | grep GNU > /dev/null; then
1624 changequote(,)dnl
1625                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1626                         as_major=`echo $as_ver | sed 's/\..*//'`
1627                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1628 changequote([,])dnl
1629                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1630                                 gcc_cv_as_leb128="no"
1631                         fi
1632                 fi
1633         fi
1634         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1635 fi
1636 if test x"$gcc_cv_as_leb128" = xyes; then
1637         AC_DEFINE(HAVE_AS_LEB128, 1,
1638                 [Define if your assembler supports .uleb128.])
1639 fi
1640 AC_MSG_RESULT($gcc_cv_as_leb128)
1641
1642 AC_MSG_CHECKING(assembler eh_frame optimization)
1643 gcc_cv_as_eh_frame=no
1644 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1645   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1646     gcc_cv_as_eh_frame="yes"
1647   fi
1648 elif test x$gcc_cv_as != x; then
1649         # Check if this is GAS.
1650         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1651         rm -f a.out 2> /dev/null
1652         if echo "$as_ver" | grep GNU > /dev/null; then
1653                 # Versions up to and including 2.11.0 may mis-optimize
1654                 # .eh_frame data.  Try something.
1655                 cat > conftest.s <<EOF
1656         .text
1657 .LFB1:
1658         .4byte  0
1659 .L1:
1660         .4byte  0
1661 .LFE1:
1662         .section        .eh_frame,"aw",@progbits
1663 __FRAME_BEGIN__:
1664         .4byte  .LECIE1-.LSCIE1
1665 .LSCIE1:
1666         .4byte  0x0
1667         .byte   0x1
1668         .ascii "z\0"
1669         .byte   0x1
1670         .byte   0x78
1671         .byte   0x1a
1672         .byte   0x0
1673         .byte   0x4
1674         .4byte  1
1675         .p2align 1
1676 .LECIE1:
1677 .LSFDE1:
1678         .4byte  .LEFDE1-.LASFDE1
1679 .LASFDE1:
1680         .4byte  .LASFDE1-__FRAME_BEGIN__
1681         .4byte  .LFB1
1682         .4byte  .LFE1-.LFB1
1683         .byte   0x4
1684         .4byte  .LFE1-.LFB1
1685         .byte   0x4
1686         .4byte  .L1-.LFB1
1687 .LEFDE1:
1688 EOF
1689                 cat > conftest.lit <<EOF
1690  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1691  0010 01000000 12000000 18000000 00000000  ................
1692  0020 08000000 04080000 0044               .........D
1693 EOF
1694                 cat > conftest.big <<EOF
1695  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1696  0010 00000001 00000012 00000018 00000000  ................
1697  0020 00000008 04000000 0844               .........D
1698 EOF
1699                 # If the assembler didn't choke, and we can objdump,
1700                 # and we got the correct data, then succeed.
1701                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1702                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1703                       | tail -3 > conftest.got \
1704                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1705                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1706                 then
1707                         gcc_cv_as_eh_frame="yes"
1708                 else
1709                         gcc_cv_as_eh_frame="bad"
1710                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1711                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1712         [Define if your assembler mis-optimizes .eh_frame data.])
1713                         fi
1714                 fi
1715         fi
1716         rm -f conftest.*
1717 fi
1718 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1719
1720 AC_MSG_CHECKING(assembler section merging support)
1721 gcc_cv_as_shf_merge=no
1722 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1723   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1724     gcc_cv_as_shf_merge=yes
1725   fi
1726 elif test x$gcc_cv_as != x; then
1727         # Check if we support SHF_MERGE sections
1728         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1729         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1730                 gcc_cv_as_shf_merge=yes
1731         fi
1732         rm -f conftest.s conftest.o
1733 fi
1734 if test x"$gcc_cv_as_shf_merge" = xyes; then
1735         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
1736 [Define if your assembler supports marking sections with SHF_MERGE flag.])
1737 fi
1738 AC_MSG_RESULT($gcc_cv_as_shf_merge)
1739
1740 AC_MSG_CHECKING(assembler thread-local storage support)
1741 gcc_cv_as_tls=no
1742 conftest_s=
1743 tls_first_major=
1744 tls_first_minor=
1745 case "$target" in
1746 changequote(,)dnl
1747   alpha*-*-*)
1748     conftest_s='
1749         .section ".tdata","awT",@progbits
1750 foo:    .long   25
1751         .text
1752         ldq     $27,__tls_get_addr($29)         !literal!1
1753         lda     $16,foo($29)                    !tlsgd!1
1754         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
1755         ldq     $27,__tls_get_addr($29)         !literal!2
1756         lda     $16,foo($29)                    !tlsldm!2
1757         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
1758         ldq     $1,foo($29)                     !gotdtprel
1759         ldah    $2,foo($29)                     !dtprelhi
1760         lda     $3,foo($2)                      !dtprello
1761         lda     $4,foo($29)                     !dtprel
1762         ldq     $1,foo($29)                     !gottprel
1763         ldah    $2,foo($29)                     !tprelhi
1764         lda     $3,foo($2)                      !tprello
1765         lda     $4,foo($29)                     !tprel'
1766         tls_first_major=2
1767         tls_first_minor=13
1768         ;;
1769   i[34567]86-*-*)
1770 changequote([,])dnl
1771     conftest_s='
1772         .section ".tdata","awT",@progbits
1773 foo:    .long   25
1774         .text
1775         movl    %gs:0, %eax
1776         leal    foo@TLSGD(,%ebx,1), %eax
1777         leal    foo@TLSLDM(%ebx), %eax
1778         leal    foo@DTPOFF(%eax), %edx
1779         movl    foo@GOTTPOFF(%ebx), %eax
1780         subl    foo@GOTTPOFF(%ebx), %eax
1781         movl    $foo@TPOFF, %eax
1782         subl    $foo@TPOFF, %eax
1783         leal    foo@NTPOFF(%ecx), %eax'
1784         tls_first_major=2
1785         tls_first_minor=13
1786         ;;
1787   ia64-*-*)
1788     conftest_s='
1789         .section ".tdata","awT",@progbits
1790 foo:    data8   25
1791         .text
1792         addl    r16 = @ltoff(@dtpmod(foo#)), gp
1793         addl    r17 = @ltoff(@dtprel(foo#)), gp
1794         addl    r18 = @ltoff(@tprel(foo#)), gp
1795         addl    r19 = @dtprel(foo#), gp
1796         adds    r21 = @dtprel(foo#), r13
1797         movl    r23 = @dtprel(foo#)
1798         addl    r20 = @tprel(foo#), gp
1799         adds    r22 = @tprel(foo#), r13
1800         movl    r24 = @tprel(foo#)'
1801         tls_first_major=2
1802         tls_first_minor=13
1803         ;;
1804 esac
1805 if test -z "$tls_first_major"; then
1806   :
1807 elif test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
1808 then
1809   if test "$gcc_cv_gas_major_version" -eq "$tls_first_major" \
1810           -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \
1811           -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then
1812     gcc_cv_as_tls=yes
1813   fi
1814 elif test x$gcc_cv_as != x; then
1815   echo "$conftest_s" > conftest.s
1816   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
1817   then
1818     gcc_cv_as_tls=yes
1819   fi
1820   rm -f conftest.s conftest.o
1821 fi
1822 if test "$gcc_cv_as_tls" = yes; then
1823   AC_DEFINE(HAVE_AS_TLS, 1,
1824             [Define if your assembler supports thread-local storage.])
1825 fi
1826 AC_MSG_RESULT($gcc_cv_as_tls)
1827
1828 case "$target" in
1829   # All TARGET_ABI_OSF targets.
1830   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
1831     AC_CACHE_CHECK([assembler supports explicit relocations],
1832         gcc_cv_as_explicit_relocs, [
1833         gcc_cv_as_explicit_relocs=unknown
1834         if test x$gcc_cv_gas_major_version != x \
1835                 -a x$gcc_cv_gas_minor_version != x
1836         then
1837            if test "$gcc_cv_gas_major_version" -eq 2 \
1838                    -a "$gcc_cv_gas_minor_version" -ge 12 \
1839                    -o "$gcc_cv_gas_major_version" -gt 2; then
1840               gcc_cv_as_explicit_relocs=yes
1841            fi
1842         elif test x$gcc_cv_as != x; then
1843             cat > conftest.s << 'EOF'
1844         .set nomacro
1845         .text
1846         extbl   $3, $2, $3      !lituse_bytoff!1
1847         ldq     $2, a($29)      !literal!1
1848         ldq     $4, b($29)      !literal!2
1849         ldq_u   $3, 0($2)       !lituse_base!1
1850         ldq     $27, f($29)     !literal!5
1851         jsr     $26, ($27), f   !lituse_jsr!5
1852         ldah    $29, 0($26)     !gpdisp!3
1853         lda     $0, c($29)      !gprel
1854         ldah    $1, d($29)      !gprelhigh
1855         lda     $1, d($1)       !gprellow
1856         lda     $29, 0($29)     !gpdisp!3
1857 EOF
1858             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1859                 gcc_cv_as_explicit_relocs=yes
1860             else
1861                 gcc_cv_as_explicit_relocs=no
1862             fi
1863             rm -f conftest.s conftest.o
1864         fi
1865     ])
1866     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
1867         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
1868                 [Define if your assembler supports explicit relocations.])
1869     fi
1870     ;;
1871   sparc*-*-*)
1872     AC_CACHE_CHECK([assembler .register pseudo-op support],
1873         gcc_cv_as_register_pseudo_op, [
1874         gcc_cv_as_register_pseudo_op=unknown
1875         if test x$gcc_cv_as != x; then
1876             # Check if we have .register
1877             echo ".register %g2, #scratch" > conftest.s
1878             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1879                 gcc_cv_as_register_pseudo_op=yes
1880             else
1881                 gcc_cv_as_register_pseudo_op=no
1882             fi
1883             rm -f conftest.s conftest.o
1884         fi
1885     ])
1886     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
1887         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
1888                 [Define if your assembler supports .register.])
1889     fi
1890
1891     AC_CACHE_CHECK([assembler supports -relax],
1892         gcc_cv_as_relax_opt, [
1893         gcc_cv_as_relax_opt=unknown
1894         if test x$gcc_cv_as != x; then
1895             # Check if gas supports -relax
1896             echo ".text" > conftest.s
1897             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
1898                 gcc_cv_as_relax_opt=yes
1899             else
1900                 gcc_cv_as_relax_opt=no
1901             fi
1902             rm -f conftest.s conftest.o
1903         fi
1904     ])
1905     if test "x$gcc_cv_as_relax_opt" = xyes; then
1906         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
1907                 [Define if your assembler supports -relax option.])
1908     fi
1909
1910     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
1911         gcc_cv_as_sparc_ua_pcrel, [
1912         gcc_cv_as_sparc_ua_pcrel=unknown
1913         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
1914             gcc_cv_as_sparc_ua_pcrel=no
1915             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
1916             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
1917                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
1918                 gcc_cv_as_sparc_ua_pcrel=yes
1919             fi
1920             rm -f conftest.s conftest.o conftest
1921         fi
1922     ])
1923     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
1924         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
1925                 [Define if your assembler and linker support unaligned PC relative relocs.])
1926     fi
1927
1928     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
1929         gcc_cv_as_sparc_ua_pcrel_hidden, [
1930         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
1931             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
1932             if test x$gcc_cv_objdump != x; then
1933                 gcc_cv_as_sparc_ua_pcrel_hidden=no
1934                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
1935                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
1936                 echo "foo: .skip 4" >> conftest.s
1937                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
1938                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
1939                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
1940                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
1941                     if $gcc_cv_objdump -R conftest 2> /dev/null \
1942                        | grep 'DISP32' > /dev/null 2>&1; then
1943                         :
1944                     else
1945                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
1946                     fi
1947                 fi
1948             fi
1949             rm -f conftest.s conftest.o conftest
1950         else
1951             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
1952         fi
1953     ])
1954     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
1955         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
1956                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
1957     fi
1958
1959     if test "x$gcc_cv_as_flags64" != xno; then
1960         AC_CACHE_CHECK([for assembler offsetable %lo() support],
1961             gcc_cv_as_offsetable_lo10, [
1962             gcc_cv_as_offsetable_lo10=unknown
1963             if test "x$gcc_cv_as" != x; then
1964                 # Check if assembler has offsetable %lo()
1965                 echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
1966                 echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
1967                 if $gcc_cv_as $gcc_cv_as_flags64 -o conftest.o conftest.s \
1968                         > /dev/null 2>&1 &&
1969                    $gcc_cv_as $gcc_cv_as_flags64 -o conftest1.o conftest1.s \
1970                         > /dev/null 2>&1; then
1971                     if cmp conftest.o conftest1.o > /dev/null 2>&1; then
1972                         gcc_cv_as_offsetable_lo10=no
1973                     else
1974                         gcc_cv_as_offsetable_lo10=yes
1975                     fi
1976                 else
1977                     gcc_cv_as_offsetable_lo10=no
1978                 fi
1979                 rm -f conftest.s conftest.o conftest1.s conftest1.o
1980             fi
1981         ])
1982         if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
1983             AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
1984                 [Define if your assembler supports offsetable %lo().])
1985         fi
1986     fi
1987
1988     ;;
1989
1990 changequote(,)dnl
1991   i[34567]86-*-* | x86_64-*-*)
1992 changequote([,])dnl
1993     AC_MSG_CHECKING(assembler instructions)
1994     gcc_cv_as_instructions=
1995     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1996       if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2; then
1997         gcc_cv_as_instructions="filds fists"
1998       fi
1999     elif test x$gcc_cv_as != x; then
2000         set "filds fists" "filds mem; fists mem"
2001         while test $# -gt 0
2002         do
2003                 echo "$2" > conftest.s
2004                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2005                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2006                 fi
2007                 shift 2
2008         done
2009         rm -f conftest.s conftest.o
2010     fi
2011     if test x"$gcc_cv_as_instructions" != x; then
2012         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2013     fi
2014     AC_MSG_RESULT($gcc_cv_as_instructions)
2015
2016     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2017     gcc_cv_as_gotoff_in_data=no
2018     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
2019     then
2020       if test "$gcc_cv_gas_major_version" -eq 2 \
2021          -a "$gcc_cv_gas_minor_version" -ge 11 \
2022          -o "$gcc_cv_gas_major_version" -gt 2; then
2023         gcc_cv_as_gotoff_in_data=yes
2024       fi
2025     elif test x$gcc_cv_as != x; then
2026         cat > conftest.s <<EOF
2027         .text
2028 .L0:
2029         nop
2030         .data
2031         .long .L0@GOTOFF
2032 EOF
2033         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2034           gcc_cv_as_gotoff_in_data=yes
2035         fi
2036     fi
2037     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2038       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2039       [Define true if the assembler supports '.long foo@GOTOFF'.])
2040     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2041     ;;
2042 esac
2043
2044 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2045 gcc_cv_as_dwarf2_debug_line=no
2046 # ??? Not all targets support dwarf2 debug_line, even within a version
2047 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2048 # info to the output file.  So, as supported targets are added to gas 2.11,
2049 # add some instruction here to (also) show we expect this might work.
2050 # ??? Once 2.11 is released, probably need to add first known working
2051 # version to the per-target configury.
2052 case "$target" in
2053   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* | x86_64*-*-* | hppa*-*-*)
2054     insn="nop"
2055     ;;
2056   ia64*-*-*)
2057     insn="nop 0"
2058     ;;
2059   esac
2060 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2061 then
2062   if test "$gcc_cv_gas_major_version" -eq 2 \
2063         -a "$gcc_cv_gas_minor_version" -ge 11 \
2064         -o "$gcc_cv_gas_major_version" -gt 2 \
2065      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2066      && test x"$insn" != x ; then
2067     gcc_cv_as_dwarf2_debug_line="yes"
2068   fi
2069 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2070         echo '  .file 1 "conftest.s"' > conftest.s
2071         echo '  .loc 1 3 0' >> conftest.s
2072         echo "  $insn" >> conftest.s
2073         # ??? This fails with non-gnu grep.
2074         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2075            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2076                 # The .debug_line file table must be in the exact order that
2077                 # we specified the files, since these indices are also used
2078                 # by DW_AT_decl_file.  Approximate this test by testing if
2079                 # the assembler bitches if the same index is assigned twice.
2080                 echo '  .file 1 "foo.s"' > conftest.s
2081                 echo '  .file 1 "bar.s"' >> conftest.s
2082                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2083                 then
2084                   gcc_cv_as_dwarf2_debug_line="no"
2085                 else
2086                   gcc_cv_as_dwarf2_debug_line="yes"
2087                 fi
2088         fi
2089         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2090 fi
2091 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2092         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2093 [Define if your assembler supports dwarf2 .file/.loc directives,
2094    and preserves file table indices exactly as given.])
2095 fi
2096 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2097
2098 AC_MSG_CHECKING(assembler --gdwarf2 support)
2099 gcc_cv_as_gdwarf2_flag=no
2100 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2101 then
2102   if test "$gcc_cv_gas_major_version" -eq 2 \
2103         -a "$gcc_cv_gas_minor_version" -ge 11 \
2104         -o "$gcc_cv_gas_major_version" -gt 2 \
2105      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2106      && test x"$insn" != x ; then
2107     gcc_cv_as_gdwarf2_debug_flag="yes"
2108   fi
2109 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2110         echo '' > conftest.s
2111         # ??? This fails with non-gnu grep.
2112         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2113           then
2114           gcc_cv_as_gdwarf2_flag="yes"
2115         fi
2116         rm -f conftest.s conftest.o
2117 fi
2118 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2119         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2120 [Define if your assembler supports the --gdwarf2 option.])
2121 fi
2122 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2123
2124 AC_MSG_CHECKING(assembler --gstabs support)
2125 gcc_cv_as_gstabs_flag=no
2126 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2127 then
2128   if test "$gcc_cv_gas_major_version" -eq 2 \
2129         -a "$gcc_cv_gas_minor_version" -ge 11 \
2130         -o "$gcc_cv_gas_major_version" -gt 2 \
2131      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2132      && test x"$insn" != x ; then
2133     gcc_cv_as_gstabs_debug_flag="yes"
2134   fi
2135 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2136         echo '' > conftest.s
2137         # ??? This fails with non-gnu grep.
2138         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2139           gcc_cv_as_gstabs_flag="yes"
2140         fi
2141         rm -f conftest.s conftest.o
2142 fi
2143 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2144         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2145 [Define if your assembler supports the --gstabs option.])
2146 fi
2147 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2148
2149 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2150 gcc_cv_ld_eh_frame_hdr=no
2151 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2152   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 12 -o "$gcc_cv_gld_major_version" -gt 2 && grep 'EMUL = elf' ../ld/Makefile > /dev/null; then
2153     gcc_cv_ld_eh_frame_hdr=yes
2154   fi
2155 elif test x$gcc_cv_ld != x; then
2156         # Check if linker supports --eh-frame-hdr option
2157         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2158                 gcc_cv_ld_eh_frame_hdr=yes
2159         fi
2160 fi
2161 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2162         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2163 [Define if your linker supports --eh-frame-hdr option.])
2164 fi
2165 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2166
2167 if test "$prefix" != "/usr" && test "$prefix" != "/usr/local" ; then
2168   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2169 fi
2170
2171 # Figure out what language subdirectories are present.
2172 # Look if the user specified --enable-languages="..."; if not, use
2173 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2174 # go away some day.
2175 # NB:  embedded tabs in this IF block -- do not untabify
2176 if test x"${enable_languages+set}" != xset; then
2177         if test x"${LANGUAGES+set}" = xset; then
2178                 enable_languages="${LANGUAGES}"
2179                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2180
2181         else
2182                 enable_languages=all
2183         fi
2184 else
2185         if test x"${enable_languages}" = x;
2186         then
2187                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2188         fi
2189 fi
2190 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2191
2192 # First scan to see if an enabled language requires some other language.
2193 # We assume that a given config-lang.in will list all the language
2194 # front ends it requires, even if some are required indirectly.
2195 for lang in ${srcdir}/*/config-lang.in ..
2196 do
2197    case $lang in
2198     ..)
2199        ;;
2200     # The odd quoting in the next line works around
2201     # an apparent bug in bash 1.12 on linux.
2202 changequote(,)dnl
2203     ${srcdir}/[*]/config-lang.in)
2204        ;;
2205     *)
2206        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2207        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2208        for other in $this_lang_requires
2209        do
2210           case ,${enable_languages}, in
2211            *,$other,*)
2212               ;;
2213            *,all,*)
2214               ;;
2215            *,$lang_alias,*)
2216               enable_languages="$enable_languages,$other"
2217               ;;
2218           esac
2219        done
2220        ;;
2221 changequote([,])dnl
2222    esac
2223 done
2224
2225 remaining_languages=${enable_languages}
2226 subdirs=
2227 for lang in ${srcdir}/*/config-lang.in ..
2228 do
2229         case $lang in
2230         ..) ;;
2231         # The odd quoting in the next line works around
2232         # an apparent bug in bash 1.12 on linux.
2233 changequote(,)dnl
2234         ${srcdir}/[*]/config-lang.in) ;;
2235         *)
2236           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2237           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2238           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2239           if test "x$lang_alias" = x
2240           then
2241                 echo "$lang doesn't set \$language." 1>&2
2242                 exit 1
2243           fi
2244           case ${build_by_default},${enable_languages}, in
2245           *,$lang_alias,*) add_this_lang=yes ;;
2246           no,*) add_this_lang=no ;;
2247           *,all,*) add_this_lang=yes ;;
2248           *) add_this_lang=no ;;
2249           esac
2250           if test x"${add_this_lang}" = xyes; then
2251                 remaining_languages=`echo $remaining_languages | sed -e s/${lang_alias}//g`
2252                 case $lang in
2253                     ${srcdir}/ada/config-lang.in)
2254                         if test x$have_gnat = xyes ; then
2255                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2256                         fi
2257                         ;;
2258                     *)
2259                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2260                         ;;
2261                 esac
2262           fi
2263           ;;
2264 changequote([,])dnl
2265         esac
2266 done
2267
2268 remaining_languages_check=`echo $remaining_languages | sed -e 's/,//g' -e 's/^c$//'g`
2269 if test "xxx$remaining_languages_check" != "xxx" -a "xxx$remaining_languages_check" != "xxxall" ; then
2270     remaining_languages_clean=`echo $remaining_languages | sed -e 's/^c,//' -e 's/,c,/,/' -e 's/,c$//'  -e 's/^c$//' -e 's/,,*/,/g' -e 's/^,//g' -e 's/,$//g' `
2271     echo "Language alias(es) not found: $remaining_languages_clean"
2272     echo "Refer to the configure instructions in the doc directory"
2273     exit 1
2274 fi
2275
2276 # Make gthr-default.h if we have a thread file.
2277 gthread_flags=
2278 if test $thread_file != single; then
2279     rm -f gthr-default.h
2280     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2281     gthread_flags=-DHAVE_GTHR_DEFAULT
2282 fi
2283 AC_SUBST(gthread_flags)
2284
2285 # Find out what GC implementation we want, or may, use.
2286 AC_ARG_WITH(gc,
2287 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2288                           with the compiler],
2289 [case "$withval" in
2290   simple | page)
2291     GGC=ggc-$withval
2292     ;;
2293   *)
2294     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2295     ;;
2296 esac],
2297 [GGC=ggc-page])
2298 AC_SUBST(GGC)
2299 echo "Using $GGC for garbage collection."
2300
2301 # Use the system's zlib library.
2302 zlibdir=-L../zlib
2303 zlibinc="-I\$(srcdir)/../zlib"
2304 AC_ARG_WITH(system-zlib,
2305 [  --with-system-zlib      use installed libz],
2306 zlibdir=
2307 zlibinc=
2308 )
2309 AC_SUBST(zlibdir)
2310 AC_SUBST(zlibinc)
2311
2312 dnl Very limited version of automake's enable-maintainer-mode
2313
2314 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2315   dnl maintainer-mode is disabled by default
2316   AC_ARG_ENABLE(maintainer-mode,
2317 [  --enable-maintainer-mode
2318                           enable make rules and dependencies not useful
2319                           (and sometimes confusing) to the casual installer],
2320       maintainer_mode=$enableval,
2321       maintainer_mode=no)
2322
2323 AC_MSG_RESULT($maintainer_mode)
2324
2325 if test "$maintainer_mode" = "yes"; then
2326   MAINT=''
2327 else
2328   MAINT='#'
2329 fi
2330 AC_SUBST(MAINT)dnl
2331
2332 # With Setjmp/Longjmp based exception handling.
2333 AC_ARG_ENABLE(sjlj-exceptions,
2334 [  --enable-sjlj-exceptions
2335                           arrange to use setjmp/longjmp exception handling],
2336 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
2337 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
2338   [Define 0/1 to force the choice for exception handling model.])])
2339
2340 # Make empty files to contain the specs and options for each language.
2341 # Then add #include lines to for a compiler that has specs and/or options.
2342
2343 lang_specs_files=
2344 lang_options_files=
2345 lang_tree_files=
2346 for subdir in . $subdirs
2347 do
2348         if test -f $srcdir/$subdir/lang-specs.h; then
2349             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2350         fi
2351         if test -f $srcdir/$subdir/lang-options.h; then
2352             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2353         fi
2354         if test -f $srcdir/$subdir/$subdir-tree.def; then
2355             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2356         fi
2357 done
2358
2359 # These (without "all_") are set in each config-lang.in.
2360 # `language' must be a single word so is spelled singularly.
2361 all_languages=
2362 all_boot_languages=
2363 all_compilers=
2364 all_stagestuff=
2365 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2366 # List of language makefile fragments.
2367 all_lang_makefiles=
2368 # Files for gengtype
2369 all_gtfiles="$config_gtfiles"
2370
2371 # Add the language fragments.
2372 # Languages are added via two mechanisms.  Some information must be
2373 # recorded in makefile variables, these are defined in config-lang.in.
2374 # We accumulate them and plug them into the main Makefile.
2375 # The other mechanism is a set of hooks for each of the main targets
2376 # like `clean', `install', etc.
2377
2378 language_fragments="Make-lang"
2379 language_hooks="Make-hooks"
2380
2381 for s in .. $subdirs
2382 do
2383         if test $s != ".."
2384         then
2385                 language=
2386                 boot_language=
2387                 compilers=
2388                 stagestuff=
2389                 outputs=
2390                 gtfiles=
2391                 . ${srcdir}/$s/config-lang.in
2392                 if test "x$language" = x
2393                 then
2394                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2395                         exit 1
2396                 fi
2397                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2398                 if test -f ${srcdir}/$s/Makefile.in
2399                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2400                 fi
2401                 all_languages="$all_languages $language"
2402                 if test "x$boot_language" = xyes
2403                 then
2404                         all_boot_languages="$all_boot_languages $language"
2405                 fi
2406                 all_compilers="$all_compilers $compilers"
2407                 all_stagestuff="$all_stagestuff $stagestuff"
2408                 all_outputs="$all_outputs $outputs"
2409                 all_gtfiles="$all_gtfiles $gtfiles"
2410         fi
2411 done
2412
2413 check_languages=
2414 for language in .. $all_languages
2415 do
2416         if test $language != ".."
2417         then
2418                 check_languages="$check_languages check-$language"
2419         fi
2420 done
2421
2422 # Since we can't use `::' targets, we link each language in
2423 # with a set of hooks, reached indirectly via lang.${target}.
2424
2425 rm -f Make-hooks
2426 touch Make-hooks
2427 target_list="all.build all.cross start.encap rest.encap \
2428         info dvi generated-manpages \
2429         install-normal install-common install-info install-man \
2430         uninstall \
2431         mostlyclean clean distclean extraclean maintainer-clean \
2432         stage1 stage2 stage3 stage4"
2433 for t in $target_list
2434 do
2435         x=
2436         for lang in .. $all_languages
2437         do
2438                 if test $lang != ".."; then
2439                         x="$x $lang.$t"
2440                 fi
2441         done
2442         echo "lang.$t: $x" >> Make-hooks
2443 done
2444
2445 # Create .gdbinit.
2446
2447 echo "dir ." > .gdbinit
2448 echo "dir ${srcdir}" >> .gdbinit
2449 if test x$gdb_needs_out_file_path = xyes
2450 then
2451         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2452 fi
2453 if test "x$subdirs" != x; then
2454         for s in $subdirs
2455         do
2456                 echo "dir ${srcdir}/$s" >> .gdbinit
2457         done
2458 fi
2459 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2460
2461 # Define variables host_canonical and build_canonical
2462 # because some Cygnus local changes in the Makefile depend on them.
2463 build_canonical=${build}
2464 host_canonical=${host}
2465 target_subdir=
2466 if test "${host}" != "${target}" ; then
2467     target_subdir=${target_alias}/
2468 fi
2469 AC_SUBST(build_canonical)
2470 AC_SUBST(host_canonical)
2471 AC_SUBST(target_subdir)
2472
2473 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2474 # absolute path for gcc_tooldir based on inserting the number of up-directory
2475 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2476 # $(libsubdir)/@(unlibsubdir) based path.
2477 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2478 # make and thus we'd get different behavior depending on where we built the
2479 # sources.
2480 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2481     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2482 else
2483 changequote(<<, >>)dnl
2484 # An explanation of the sed strings:
2485 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2486 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2487 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2488 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2489 #
2490 # (*) Note this pattern overwrites the first character of the string
2491 # with a forward slash if one is not already present.  This is not a
2492 # problem because the exact names of the sub-directories concerned is
2493 # unimportant, just the number of them matters.
2494 #
2495 # The practical upshot of these patterns is like this:
2496 #
2497 #  prefix     exec_prefix        result
2498 #  ------     -----------        ------
2499 #   /foo        /foo/bar          ../
2500 #   /foo/       /foo/bar          ../
2501 #   /foo        /foo/bar/         ../
2502 #   /foo/       /foo/bar/         ../
2503 #   /foo        /foo/bar/ugg      ../../
2504 #
2505     dollar='$$'
2506     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2507 changequote([, ])dnl
2508 fi
2509 AC_SUBST(gcc_tooldir)
2510 AC_SUBST(dollar)
2511
2512 # Find a directory in which to install a shared libgcc.
2513
2514 AC_ARG_ENABLE(version-specific-runtime-libs,
2515 [  --enable-version-specific-runtime-libs
2516                           specify that runtime libraries should be
2517                           installed in a compiler-specific directory])
2518
2519 AC_ARG_WITH(slibdir,
2520 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2521 slibdir="$with_slibdir",
2522 if test "${enable_version_specific_runtime_libs+set}" = set; then
2523   slibdir='$(libsubdir)'
2524 elif test "$host" != "$target"; then
2525   slibdir='$(build_tooldir)/lib'
2526 else
2527   slibdir='$(libdir)'
2528 fi)
2529 AC_SUBST(slibdir)
2530
2531 # Nothing to do for FLOAT_H, float_format already handled.
2532 objdir=`${PWDCMD-pwd}`
2533 AC_SUBST(objdir)
2534
2535 # Process the language and host/target makefile fragments.
2536 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2537
2538 # Substitute configuration variables
2539 AC_SUBST(subdirs)
2540 AC_SUBST(all_boot_languages)
2541 AC_SUBST(all_compilers)
2542 AC_SUBST(all_gtfiles)
2543 AC_SUBST(all_lang_makefiles)
2544 AC_SUBST(all_languages)
2545 AC_SUBST(all_stagestuff)
2546 AC_SUBST(build_exeext)
2547 AC_SUBST(build_install_headers_dir)
2548 AC_SUBST(build_xm_file_list)
2549 AC_SUBST(build_xm_file)
2550 AC_SUBST(build_xm_defines)
2551 AC_SUBST(check_languages)
2552 AC_SUBST(cc_set_by_configure)
2553 AC_SUBST(quoted_cc_set_by_configure)
2554 AC_SUBST(cpp_install_dir)
2555 AC_SUBST(dep_host_xmake_file)
2556 AC_SUBST(dep_tmake_file)
2557 AC_SUBST(extra_headers_list)
2558 AC_SUBST(extra_objs)
2559 AC_SUBST(extra_parts)
2560 AC_SUBST(extra_passes)
2561 AC_SUBST(extra_programs)
2562 AC_SUBST(float_h_file)
2563 AC_SUBST(gcc_config_arguments)
2564 AC_SUBST(gcc_gxx_include_dir)
2565 AC_SUBST(libstdcxx_incdir)
2566 AC_SUBST(gcc_version)
2567 AC_SUBST(gcc_version_full)
2568 AC_SUBST(gcc_version_trigger)
2569 AC_SUBST(host_exeext)
2570 AC_SUBST(host_extra_gcc_objs)
2571 AC_SUBST(host_xm_file_list)
2572 AC_SUBST(host_xm_file)
2573 AC_SUBST(host_xm_defines)
2574 AC_SUBST(install)
2575 AC_SUBST(lang_options_files)
2576 AC_SUBST(lang_specs_files)
2577 AC_SUBST(lang_tree_files)
2578 AC_SUBST(local_prefix)
2579 AC_SUBST(md_file)
2580 AC_SUBST(objc_boehm_gc)
2581 AC_SUBST(out_file)
2582 AC_SUBST(out_object_file)
2583 AC_SUBST(stage_prefix_set_by_configure)
2584 AC_SUBST(quoted_stage_prefix_set_by_configure)
2585 AC_SUBST(symbolic_link)
2586 AC_SUBST(thread_file)
2587 AC_SUBST(tm_file_list)
2588 AC_SUBST(tm_file)
2589 AC_SUBST(tm_p_file_list)
2590 AC_SUBST(tm_p_file)
2591 AC_SUBST(xm_file)
2592 AC_SUBST(xm_defines)
2593 AC_SUBST(target_alias)
2594 AC_SUBST(c_target_objs)
2595 AC_SUBST(cxx_target_objs)
2596 AC_SUBST(target_cpu_default)
2597
2598 AC_SUBST_FILE(target_overrides)
2599 AC_SUBST_FILE(host_overrides)
2600 AC_SUBST_FILE(language_fragments)
2601 AC_SUBST_FILE(language_hooks)
2602
2603 # Echo that links are built
2604 if test x$host = x$target
2605 then
2606         str1="native "
2607 else
2608         str1="cross-"
2609         str2=" from $host"
2610 fi
2611
2612 if test x$host != x$build
2613 then
2614         str3=" on a $build system"
2615 fi
2616
2617 if test "x$str2" != x || test "x$str3" != x
2618 then
2619         str4=
2620 fi
2621
2622 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
2623
2624 if test "x$str2" != x || test "x$str3" != x
2625 then
2626         echo " ${str2}${str3}." 1>&2
2627 fi
2628
2629 # Truncate the target if necessary
2630 if test x$host_truncate_target != x; then
2631         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
2632 fi
2633
2634 # Configure the subdirectories
2635 # AC_CONFIG_SUBDIRS($subdirs)
2636
2637 # Create the Makefile
2638 # and configure language subdirectories
2639 AC_OUTPUT($all_outputs,
2640 [
2641 case x$CONFIG_HEADERS in
2642 xauto-host.h:config.in)
2643 echo > cstamp-h ;;
2644 esac
2645 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
2646 # bootstrapping and the installation procedure can still use
2647 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
2648 # FLAGS_TO_PASS has been modified to solve the problem there.
2649 # This is virtually a duplicate of what happens in configure.lang; we do
2650 # an extra check to make sure this only happens if ln -s can be used.
2651 if test "$symbolic_link" = "ln -s"; then
2652  for d in .. ${subdirs} fixinc ; do
2653    if test $d != ..; then
2654         STARTDIR=`${PWDCMD-pwd}`
2655         cd $d
2656         for t in stage1 stage2 stage3 stage4 include
2657         do
2658                 rm -f $t
2659                 $symbolic_link ../$t $t 2>/dev/null
2660         done
2661         cd $STARTDIR
2662    fi
2663  done
2664 else true ; fi
2665 # Avoid having to add intl to our include paths.
2666 if test -f intl/libintl.h; then
2667   echo creating libintl.h
2668   echo '#include "intl/libintl.h"' >libintl.h
2669 fi
2670 ],
2671 [subdirs='$subdirs'
2672 symbolic_link='$symbolic_link'
2673 ])