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