gcc/configure.ac

   1 # configure.ac for GCC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   5 # Free Software Foundation, Inc.
   6
   7 #This file is part of GCC.
   8
   9 #GCC is free software; you can redistribute it and/or modify it under
  10 #the terms of the GNU General Public License as published by the Free
  11 #Software Foundation; either version 2, or (at your option) any later
  12 #version.
  13
  14 #GCC is distributed in the hope that it will be useful, but WITHOUT
  15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 #for more details.
  18
  19 #You should have received a copy of the GNU General Public License
  20 #along with GCC; see the file COPYING.  If not, write to the Free
  21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 #02111-1307, USA.
  23
  24 # --------------------------------
  25 # Initialization and sanity checks
  26 # --------------------------------
  27
  28 AC_PREREQ(2.59)
  29 AC_INIT
  30 AC_CONFIG_SRCDIR(tree.c)
  31 AC_CONFIG_HEADER(auto-host.h:config.in)
  32
  33 #Set to 1 on a release branch
  34 is_release=
  35
  36 # Determine the host, build, and target systems
  37 AC_CANONICAL_BUILD
  38 AC_CANONICAL_HOST
  39 AC_CANONICAL_TARGET
  40
  41 # Determine the noncanonical target name, for directory use.
  42 ACX_NONCANONICAL_TARGET
  43
  44 # Determine the target- and build-specific subdirectories
  45 GCC_TOPLEV_SUBDIRS
  46
  47 # Set program_transform_name
  48 AC_ARG_PROGRAM
  49
  50 # Check for bogus environment variables.
  51 # Test if LIBRARY_PATH contains the notation for the current directory
  52 # since this would lead to problems installing/building glibc.
  53 # LIBRARY_PATH contains the current directory if one of the following
  54 # is true:
  55 # - one of the terminals (":" and ";") is the first or last sign
  56 # - two terminals occur directly after each other
  57 # - the path contains an element with a dot in it
  58 AC_MSG_CHECKING(LIBRARY_PATH variable)
  59 changequote(,)dnl
  60 case ${LIBRARY_PATH} in
  61   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  62     library_path_setting="contains current directory"
  63     ;;
  64   *)
  65     library_path_setting="ok"
  66     ;;
  67 esac
  68 changequote([,])dnl
  69 AC_MSG_RESULT($library_path_setting)
  70 if test "$library_path_setting" != "ok"; then
  71 AC_MSG_ERROR([
  72 *** LIBRARY_PATH shouldn't contain the current directory when
  73 *** building gcc. Please change the environment variable
  74 *** and run configure again.])
  75 fi
  76
  77 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  78 # since this would lead to problems installing/building glibc.
  79 # GCC_EXEC_PREFIX contains the current directory if one of the following
  80 # is true:
  81 # - one of the terminals (":" and ";") is the first or last sign
  82 # - two terminals occur directly after each other
  83 # - the path contains an element with a dot in it
  84 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  85 changequote(,)dnl
  86 case ${GCC_EXEC_PREFIX} in
  87   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  88     gcc_exec_prefix_setting="contains current directory"
  89     ;;
  90   *)
  91     gcc_exec_prefix_setting="ok"
  92     ;;
  93 esac
  94 changequote([,])dnl
  95 AC_MSG_RESULT($gcc_exec_prefix_setting)
  96 if test "$gcc_exec_prefix_setting" != "ok"; then
  97 AC_MSG_ERROR([
  98 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  99 *** building gcc. Please change the environment variable
 100 *** and run configure again.])
 101 fi
 102
 103 # -----------
 104 # Directories
 105 # -----------
 106
 107 # Specify the local prefix
 108 local_prefix=
 109 AC_ARG_WITH(local-prefix,
 110 [  --with-local-prefix=DIR specifies directory to put local include],
 111 [case "${withval}" in
 112 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 113 no)     ;;
 114 *)      local_prefix=$with_local_prefix ;;
 115 esac])
 116
 117 # Default local prefix if it is empty
 118 if test x$local_prefix = x; then
 119         local_prefix=/usr/local
 120 fi
 121
 122 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 123 # passed in by the toplevel make and thus we'd get different behavior
 124 # depending on where we built the sources.
 125 gcc_gxx_include_dir=
 126 # Specify the g++ header file directory
 127 AC_ARG_WITH(gxx-include-dir,
 128 [  --with-gxx-include-dir=DIR
 129                           specifies directory to put g++ header files],
 130 [case "${withval}" in
 131 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 132 no)     ;;
 133 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 134 esac])
 135
 136 if test x${gcc_gxx_include_dir} = x; then
 137   if test x${enable_version_specific_runtime_libs} = xyes; then
 138     gcc_gxx_include_dir='${libsubdir}/include/c++'
 139   else
 140     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 141 changequote(<<, >>)dnl
 142     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 143 changequote([, ])dnl
 144   fi
 145 fi
 146
 147 AC_ARG_WITH(cpp_install_dir,
 148 [  --with-cpp-install-dir=DIR
 149                           install the user visible C preprocessor in DIR
 150                           (relative to PREFIX) as well as PREFIX/bin],
 151 [if test x$withval = xyes; then
 152   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 153 elif test x$withval != xno; then
 154   cpp_install_dir=$withval
 155 fi])
 156
 157 # We would like to our source tree to be readonly.  However when releases or
 158 # pre-releases are generated, the flex/bison generated files as well as the
 159 # various formats of manuals need to be included along with the rest of the
 160 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 161 # just that.
 162
 163 AC_MSG_CHECKING([whether to place generated files in the source directory])
 164   dnl generated-files-in-srcdir is disabled by default
 165   AC_ARG_ENABLE(generated-files-in-srcdir,
 166 [  --enable-generated-files-in-srcdir
 167                           put copies of generated files in source dir
 168                           intended for creating source tarballs for users
 169                           without texinfo bison or flex.],
 170       generated_files_in_srcdir=$enableval,
 171       generated_files_in_srcdir=no)
 172
 173 AC_MSG_RESULT($generated_files_in_srcdir)
 174
 175 if test "$generated_files_in_srcdir" = "yes"; then
 176   GENINSRC=''
 177 else
 178   GENINSRC='#'
 179 fi
 180 AC_SUBST(GENINSRC)
 181
 182 # -------------------
 183 # Find default linker
 184 # -------------------
 185
 186 # With GNU ld
 187 AC_ARG_WITH(gnu-ld,
 188 [  --with-gnu-ld           arrange to work with GNU ld.],
 189 gnu_ld_flag="$with_gnu_ld",
 190 gnu_ld_flag=no)
 191
 192 # With pre-defined ld
 193 AC_ARG_WITH(ld,
 194 [  --with-ld               arrange to use the specified ld (full pathname)],
 195 DEFAULT_LINKER="$with_ld")
 196 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 197   if test ! -x "$DEFAULT_LINKER"; then
 198     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 199   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 200     gnu_ld_flag=yes
 201   fi
 202   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 203         [Define to enable the use of a default linker.])
 204 fi
 205
 206 AC_MSG_CHECKING([whether a default linker was specified])
 207 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 208   if test x"$gnu_ld_flag" = x"no"; then
 209     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 210   else
 211     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 212   fi
 213 else
 214   AC_MSG_RESULT(no)
 215 fi
 216
 217 # With demangler in GNU ld
 218 AC_ARG_WITH(demangler-in-ld,
 219 [  --with-demangler-in-ld  try to use demangler in GNU ld.],
 220 demangler_in_ld="$with_demangler_in_ld",
 221 demangler_in_ld=no)
 222
 223 # ----------------------
 224 # Find default assembler
 225 # ----------------------
 226
 227 # With GNU as
 228 AC_ARG_WITH(gnu-as,
 229 [  --with-gnu-as           arrange to work with GNU as],
 230 gas_flag="$with_gnu_as",
 231 gas_flag=no)
 232
 233 AC_ARG_WITH(as,
 234 [  --with-as               arrange to use the specified as (full pathname)],
 235 DEFAULT_ASSEMBLER="$with_as")
 236 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 237   if test ! -x "$DEFAULT_ASSEMBLER"; then
 238     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 239   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 240     gas_flag=yes
 241   fi
 242   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 243         [Define to enable the use of a default assembler.])
 244 fi
 245
 246 AC_MSG_CHECKING([whether a default assembler was specified])
 247 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 248   if test x"$gas_flag" = x"no"; then
 249     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 250   else
 251     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 252   fi
 253 else
 254   AC_MSG_RESULT(no)
 255 fi
 256
 257 # ---------------
 258 # Find C compiler
 259 # ---------------
 260
 261 # If a non-executable a.out is present (e.g. created by GNU as above even if
 262 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
 263 # file, even when creating an executable, so an execution test fails.
 264 # Remove possible default executable files to avoid this.
 265 #
 266 # FIXME: This really belongs into AC_PROG_CC and can be removed once
 267 # Autoconf includes it.
 268 rm -f a.out a.exe b.out
 269
 270 # Find the native compiler
 271 AC_PROG_CC
 272 AM_PROG_CC_C_O
 273 # autoconf is lame and doesn't give us any substitution variable for this.
 274 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 275   NO_MINUS_C_MINUS_O=yes
 276 else
 277   OUTPUT_OPTION='-o $@'
 278 fi
 279 AC_SUBST(NO_MINUS_C_MINUS_O)
 280 AC_SUBST(OUTPUT_OPTION)
 281
 282 # -------------------------
 283 # Check C compiler features
 284 # -------------------------
 285
 286 AC_PROG_CPP
 287 AC_C_INLINE
 288
 289 gcc_AC_C_LONG_LONG
 290
 291 # sizeof(char) is 1 by definition.
 292 AC_CHECK_SIZEOF(void *)
 293 AC_CHECK_SIZEOF(short)
 294 AC_CHECK_SIZEOF(int)
 295 AC_CHECK_SIZEOF(long)
 296 if test $ac_cv_c_long_long = yes; then
 297   AC_CHECK_SIZEOF(long long)
 298 fi
 299 if test $ac_cv_c___int64 = yes; then
 300   AC_CHECK_SIZEOF(__int64)
 301 fi
 302
 303 # ---------------------
 304 # Warnings and checking
 305 # ---------------------
 306
 307 # Check $CC warning features (if it's GCC).
 308 # We want to use -pedantic, but we don't want warnings about
 309 # * 'long long'
 310 # * variadic macros
 311 # So, we only use -pedantic if we can disable those warnings.
 312
 313 AC_CACHE_CHECK(
 314   [whether ${CC} accepts -Wno-long-long],
 315   [ac_cv_prog_cc_w_no_long_long],
 316   [save_CFLAGS="$CFLAGS"
 317   CFLAGS="-Wno-long-long"
 318   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 319                     [ac_cv_prog_cc_w_no_long_long=yes],
 320                     [ac_cv_prog_cc_w_no_long_long=no])
 321   CFLAGS="$save_CFLAGS"
 322   ])
 323
 324 AC_CACHE_CHECK(
 325   [whether ${CC} accepts -Wno-variadic-macros],
 326   [ac_cv_prog_cc_w_no_variadic_macros],
 327   [save_CFLAGS="$CFLAGS"
 328   CFLAGS="-Wno-variadic-macros"
 329   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 330                     [ac_cv_prog_cc_w_no_variadic_macros=yes],
 331                     [ac_cv_prog_cc_w_no_variadic_macros=no])
 332   CFLAGS="$save_CFLAGS"
 333   ])
 334
 335 strict1_warn=
 336 if test $ac_cv_prog_cc_w_no_long_long = yes \
 337    && test $ac_cv_prog_cc_w_no_variadic_macros = yes ; then
 338   strict1_warn="-pedantic -Wno-long-long -Wno-variadic-macros"
 339 fi
 340 AC_SUBST(strict1_warn)
 341
 342 # Add -Wold-style-definition if it's accepted
 343 AC_CACHE_CHECK(
 344   [whether ${CC} accepts -Wold-style-definition],
 345   [ac_cv_prog_cc_w_old_style_definition],
 346   [save_CFLAGS="$CFLAGS"
 347   CFLAGS="-Wold-style-definition"
 348   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 349                     [ac_cv_prog_cc_w_old_style_definition=yes],
 350                     [ac_cv_prog_cc_w_old_style_definition=no])
 351   CFLAGS="$save_CFLAGS"
 352   ])
 353 if test $ac_cv_prog_cc_w_old_style_definition = yes ; then
 354   strict1_warn="${strict1_warn} -Wold-style-definition"
 355 fi
 356
 357 # Enable -Werror, period.
 358 AC_ARG_ENABLE(werror_always,
 359 [  --enable-werror-always         enable -Werror always], [],
 360 [enable_werror_always=no])
 361 if test x${enable_werror_always} = xyes ; then
 362   strict1_warn="${strict1_warn} -Werror"
 363   WERROR=-Werror
 364 fi
 365
 366 # If the native compiler is GCC, we can enable warnings even in stage1.
 367 # That's useful for people building cross-compilers, or just running a
 368 # quick `make'.
 369 warn_cflags=
 370 if test "x$GCC" = "xyes"; then
 371   warn_cflags='$(GCC_WARN_CFLAGS)'
 372 fi
 373 AC_SUBST(warn_cflags)
 374
 375 # Enable -Werror in bootstrap stage2 and later.
 376 AC_ARG_ENABLE(werror,
 377 [  --enable-werror         enable -Werror in bootstrap stage2 and later], [],
 378 [if test x$is_release = x ; then
 379   # Default to "yes" on development branches.
 380   enable_werror=yes
 381 else
 382   # Default to "no" on release branches.
 383   enable_werror=no
 384 fi])
 385 if test x$enable_werror = xyes ; then
 386   WERROR=-Werror
 387 fi
 388 AC_SUBST(WERROR)
 389
 390 # Enable expensive internal checks
 391 AC_ARG_ENABLE(checking,
 392 [  --enable-checking[=LIST]
 393                           enable expensive run-time checks.  With LIST,
 394                           enable only specific categories of checks.
 395                           Categories are: assert,fold,gc,gcac,misc,
 396                           rtlflag,rtl,tree,valgrind,release,yes,all;],
 397 [ac_checking_flags="${enableval}"],[
 398 # Determine the default checks.
 399 if test x$is_release = x ; then
 400   ac_checking_flags=yes
 401 else
 402   ac_checking_flags=release
 403 fi])
 404 ac_assert_checking=1
 405 ac_checking=
 406 ac_tree_checking=
 407 ac_rtl_checking=
 408 ac_rtlflag_checking=
 409 ac_gc_checking=
 410 ac_gc_always_collect=
 411 ac_fold_checking=
 412 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 413 for check in $ac_checking_flags
 414 do
 415         case $check in
 416         yes)            ac_assert_checking=1 ; ac_checking=1 ;
 417                         ac_tree_checking=1 ; ac_gc_checking=1 ;
 418                         ac_rtlflag_checking=1 ;;
 419         no)             ac_assert_checking= ; ac_checking= ;
 420                         ac_tree_checking= ; ac_rtl_checking= ;
 421                         ac_rtlflag_checking= ; ac_gc_checking= ;
 422                         ac_gc_always_collect= ; ac_fold_checking= ;;
 423         all)            ac_assert_checking=1 ; ac_checking=1 ;
 424                         ac_tree_checking=1 ; ac_rtl_checking=1 ;
 425                         ac_rtlflag_checking=1 ; ac_gc_checking=1 ;
 426                         ac_gc_always_collect=1 ; ac_fold_checking=1 ;;
 427         release)        ac_assert_checking=1 ;;
 428         assert)         ac_assert_checking=1 ;;
 429         fold)           ac_fold_checking=1 ;;
 430         gc)             ac_gc_checking=1 ;;
 431         gcac)           ac_gc_always_collect=1 ;;
 432         misc)           ac_checking=1 ;;
 433         rtlflag)        ac_rtlflag_checking=1 ;;
 434         rtl)            ac_rtl_checking=1 ;;
 435         tree)           ac_tree_checking=1 ;;
 436         valgrind)       ac_checking_valgrind=1 ;;
 437         *)      AC_MSG_ERROR(unknown check category $check) ;;
 438         esac
 439 done
 440 IFS="$ac_save_IFS"
 441
 442 nocommon_flag=""
 443 if test x$ac_checking != x ; then
 444   AC_DEFINE(ENABLE_CHECKING, 1,
 445 [Define if you want more run-time sanity checks.  This one gets a grab
 446    bag of miscellaneous but relatively cheap checks.])
 447   nocommon_flag=-fno-common
 448 fi
 449 AC_SUBST(nocommon_flag)
 450 if test x$ac_assert_checking != x ; then
 451   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
 452 [Define if you want assertions enabled.  This is a cheap check.])
 453 fi
 454 if test x$ac_tree_checking != x ; then
 455   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 456 [Define if you want all operations on trees (the basic data
 457    structure of the front ends) to be checked for dynamic type safety
 458    at runtime.  This is moderately expensive.  The tree browser debugging
 459    routines will also be enabled by this option.
 460    ])
 461   TREEBROWSER=tree-browser.o
 462 fi
 463 AC_SUBST(TREEBROWSER)
 464 if test x$ac_rtl_checking != x ; then
 465   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 466 [Define if you want all operations on RTL (the basic data structure
 467    of the optimizer and back end) to be checked for dynamic type safety
 468    at runtime.  This is quite expensive.])
 469 fi
 470 if test x$ac_rtlflag_checking != x ; then
 471   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 472 [Define if you want RTL flag accesses to be checked against the RTL
 473    codes that are supported for each access macro.  This is relatively
 474    cheap.])
 475 fi
 476 if test x$ac_gc_checking != x ; then
 477   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 478 [Define if you want the garbage collector to do object poisoning and
 479    other memory allocation checks.  This is quite expensive.])
 480 fi
 481 if test x$ac_gc_always_collect != x ; then
 482   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 483 [Define if you want the garbage collector to operate in maximally
 484    paranoid mode, validating the entire heap and collecting garbage at
 485    every opportunity.  This is extremely expensive.])
 486 fi
 487 if test x$ac_fold_checking != x ; then
 488   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 489 [Define if you want fold checked that it never destructs its argument.
 490    This is quite expensive.])
 491 fi
 492 valgrind_path_defines=
 493 valgrind_command=
 494
 495 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 496 dnl # an if statement.  This was the source of very frustrating bugs
 497 dnl # in converting to autoconf 2.5x!
 498 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 499
 500 if test x$ac_checking_valgrind != x ; then
 501   # It is certainly possible that there's valgrind but no valgrind.h.
 502   # GCC relies on making annotations so we must have both.
 503   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 504   AC_TRY_CPP(
 505     [#include <valgrind/memcheck.h>
 506 #ifndef VALGRIND_DISCARD
 507 #error VALGRIND_DISCARD not defined
 508 #endif],
 509   [gcc_cv_header_valgrind_memcheck_h=yes],
 510   [gcc_cv_header_valgrind_memcheck_h=no])
 511   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 512   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 513   AC_TRY_CPP(
 514     [#include <memcheck.h>
 515 #ifndef VALGRIND_DISCARD
 516 #error VALGRIND_DISCARD not defined
 517 #endif],
 518   [gcc_cv_header_memcheck_h=yes],
 519   gcc_cv_header_memcheck_h=no)
 520   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 521   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 522         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 523   if test "x$valgrind_path" = "x" \
 524     || (test $have_valgrind_h = no \
 525         && test $gcc_cv_header_memcheck_h = no \
 526         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 527         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 528   fi
 529   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 530   valgrind_command="$valgrind_path -q"
 531   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 532 [Define if you want to run subprograms and generated programs
 533    through valgrind (a memory checker).  This is extremely expensive.])
 534   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 535     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 536         [Define if valgrind's valgrind/memcheck.h header is installed.])
 537   fi
 538   if test $gcc_cv_header_memcheck_h = yes; then
 539     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 540         [Define if valgrind's memcheck.h header is installed.])
 541   fi
 542 fi
 543 AC_SUBST(valgrind_path_defines)
 544 AC_SUBST(valgrind_command)
 545
 546 AC_ARG_ENABLE(mapped-location,
 547 [  --enable-mapped-location   location_t is fileline integer cookie],,
 548 enable_mapped_location=no)
 549
 550 if test "$enable_mapped_location" = yes ; then
 551   AC_DEFINE(USE_MAPPED_LOCATION, 1,
 552 [Define if location_t is fileline integer cookie.])
 553 fi
 554
 555 # Enable code coverage collection
 556 AC_ARG_ENABLE(coverage,
 557 [  --enable-coverage[=LEVEL]
 558                           enable compiler's code coverage collection.
 559                           Use to measure compiler performance and locate
 560                           unused parts of the compiler. With LEVEL, specify
 561                           optimization. Values are opt, noopt,
 562                           default is noopt],
 563 [case "${enableval}" in
 564   yes|noopt)
 565     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 566     ;;
 567   opt)
 568     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 569     ;;
 570   no)
 571     # a.k.a. --disable-coverage
 572     coverage_flags=""
 573     ;;
 574   *)
 575     AC_MSG_ERROR(unknown coverage setting $enableval)
 576     ;;
 577 esac],
 578 [coverage_flags=""])
 579 AC_SUBST(coverage_flags)
 580
 581 AC_ARG_ENABLE(gather-detailed-mem-stats,
 582 [  --enable-gather-detailed-mem-stats         enable detailed memory allocation stats gathering], [],
 583 [enable_gather_detailed_mem_stats=no])
 584 if test x$enable_gather_detailed_mem_stats = xyes ; then
 585   AC_DEFINE(GATHER_STATISTICS, 1,
 586         [Define to enable detailed memory allocation stats gathering.])
 587 fi
 588
 589 # -------------------------------
 590 # Miscenalleous configure options
 591 # -------------------------------
 592
 593 # With stabs
 594 AC_ARG_WITH(stabs,
 595 [  --with-stabs            arrange to use stabs instead of host debug format],
 596 stabs="$with_stabs",
 597 stabs=no)
 598
 599 # Determine whether or not multilibs are enabled.
 600 AC_ARG_ENABLE(multilib,
 601 [  --enable-multilib       enable library support for multiple ABIs],
 602 [], [enable_multilib=yes])
 603 AC_SUBST(enable_multilib)
 604
 605 # Enable __cxa_atexit for C++.
 606 AC_ARG_ENABLE(__cxa_atexit,
 607 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 608 [], [])
 609
 610 # Enable threads
 611 # Pass with no value to take the default
 612 # Pass with a value to specify a thread package
 613 AC_ARG_ENABLE(threads,
 614 [  --enable-threads        enable thread usage for target GCC
 615   --enable-threads=LIB    use LIB thread package for target GCC],,
 616 [enable_threads=''])
 617
 618 AC_ARG_ENABLE(objc-gc,
 619 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 620                           the GNU Objective-C runtime],
 621 if test x$enable_objc_gc = xno; then
 622         objc_boehm_gc=''
 623 else
 624         objc_boehm_gc=1
 625 fi,
 626 objc_boehm_gc='')
 627
 628 AC_ARG_WITH(dwarf2,
 629 [  --with-dwarf2           force the default debug format to be DWARF 2],
 630 dwarf2="$with_dwarf2",
 631 dwarf2=no)
 632
 633 AC_ARG_ENABLE(shared,
 634 [  --disable-shared        don't provide a shared libgcc],
 635 [
 636   case $enable_shared in
 637   yes | no) ;;
 638   *)
 639     enable_shared=no
 640     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 641     for pkg in $enableval; do
 642       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 643         enable_shared=yes
 644       fi
 645     done
 646     IFS="$ac_save_ifs"
 647     ;;
 648   esac
 649 ], [enable_shared=yes])
 650 AC_SUBST(enable_shared)
 651
 652 AC_ARG_WITH(sysroot,
 653 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
 654 [
 655  case ${with_sysroot} in
 656  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
 657  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 658  esac
 659
 660  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 661  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
 662
 663  if test "x$exec_prefix" = xNONE; then
 664   if test "x$prefix" = xNONE; then
 665    test_prefix=/usr/local
 666   else
 667    test_prefix=$prefix
 668   fi
 669  else
 670   test_prefix=$exec_prefix
 671  fi
 672  case ${TARGET_SYSTEM_ROOT} in
 673  "${test_prefix}"|"${test_prefix}/"*|\
 674  '${exec_prefix}'|'${exec_prefix}/'*)
 675    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 676    TARGET_SYSTEM_ROOT_DEFINE="$t"
 677    ;;
 678  esac
 679 ], [
 680  TARGET_SYSTEM_ROOT=
 681  TARGET_SYSTEM_ROOT_DEFINE=
 682  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 683 ])
 684 AC_SUBST(TARGET_SYSTEM_ROOT)
 685 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 686 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 687
 688 # Build with intermodule optimisations
 689 AC_ARG_ENABLE(intermodule,
 690 [  --enable-intermodule    build the compiler in one step],
 691 [case ${enable_intermodule} in
 692   yes) onestep="-onestep";;
 693   *) onestep="";;
 694 esac],
 695 [onestep=""])
 696 AC_SUBST(onestep)
 697
 698 # Sanity check enable_languages in case someone does not run the toplevel
 699 # configure # script.
 700 AC_ARG_ENABLE(languages,
 701 [  --enable-languages=LIST specify which front-ends to build],
 702 [case ,${enable_languages}, in
 703        ,,|,yes,)
 704                 # go safe -- we cannot be much sure without the toplevel
 705                 # configure's
 706                 # analysis of which target libs are present and usable
 707                 enable_languages=c
 708                 ;;
 709          *,all,*)
 710                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
 711                 ;;
 712         *,c,*)
 713                 ;;
 714         *)
 715                 enable_languages=c,${enable_languages}
 716                 ;;
 717 esac],
 718 [enable_languages=c])
 719
 720 subdirs=
 721 for lang in ${srcdir}/*/config-lang.in
 722 do
 723         case $lang in
 724         # The odd quoting in the next line works around
 725         # an apparent bug in bash 1.12 on linux.
 726 changequote(,)dnl
 727         ${srcdir}/[*]/config-lang.in) ;;
 728         *)
 729           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
 730           if test "x$lang_alias" = x
 731           then
 732                 echo "$lang doesn't set \$language." 1>&2
 733                 exit 1
 734           fi
 735           case ",$enable_languages," in
 736           *,$lang_alias,*)
 737             subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;;
 738           esac
 739           ;;
 740 changequote([,])dnl
 741         esac
 742 done
 743
 744
 745 # -------------------------
 746 # Checks for other programs
 747 # -------------------------
 748
 749 AC_PROG_MAKE_SET
 750
 751 # Find some useful tools
 752 AC_PROG_AWK
 753 # We need awk to create options.c and options.h.
 754 # Bail out if it's missing.
 755 case ${AWK} in
 756   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
 757 esac
 758
 759 gcc_AC_PROG_LN_S
 760 ACX_PROG_LN($LN_S)
 761 AC_PROG_RANLIB
 762 case "${host}" in
 763 *-*-darwin*)
 764   # By default, the Darwin ranlib will not treat common symbols as
 765   # definitions when  building the archive table of contents.  Other
 766   # ranlibs do that; pass an option to the Darwin ranlib that makes
 767   # it behave similarly.
 768   ranlib_flags="-c"
 769   ;;
 770 *)
 771   ranlib_flags=""
 772 esac
 773 AC_SUBST(ranlib_flags)
 774
 775 gcc_AC_PROG_INSTALL
 776
 777 # See if cmp has --ignore-initial.
 778 gcc_AC_PROG_CMP_IGNORE_INITIAL
 779
 780 # See if we have the mktemp command.
 781 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 782
 783 MISSING="${CONFIG_SHELL-/bin/sh} $srcdir/../missing"
 784
 785 # See if makeinfo has been installed and is modern enough
 786 # that we can use it.
 787 gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 788   [GNU texinfo.* \([0-9][0-9.]*\)],
 789   [4.[2-9]*])
 790 if test $gcc_cv_prog_makeinfo_modern = no; then
 791   MAKEINFO="$MISSING makeinfo"
 792   AC_MSG_WARN([
 793 *** Makeinfo is missing or too old.
 794 *** Info documentation will not be built.])
 795   BUILD_INFO=
 796 else
 797   BUILD_INFO=info
 798 fi
 799 AC_SUBST(BUILD_INFO)
 800
 801 # Is pod2man recent enough to regenerate manpages?
 802 AC_MSG_CHECKING([for recent Pod::Man])
 803 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 804   AC_MSG_RESULT(yes)
 805   GENERATED_MANPAGES=generated-manpages
 806 else
 807   AC_MSG_RESULT(no)
 808   GENERATED_MANPAGES=
 809 fi
 810 AC_SUBST(GENERATED_MANPAGES)
 811
 812 # How about lex?
 813 dnl Don't use AC_PROG_LEX; we insist on flex.
 814 dnl LEXLIB is not useful in gcc.
 815 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
 816
 817 # Bison?
 818 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
 819
 820 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
 821 # check for build == host before using them.
 822
 823 # NM
 824 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
 825   && test -d ../binutils ; then
 826   NM='$(objdir)/../binutils/nm-new'
 827 else
 828   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
 829 fi
 830
 831 # AR
 832 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
 833   && test -d ../binutils ; then
 834   AR='$(objdir)/../binutils/ar'
 835 else
 836   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
 837 fi
 838
 839
 840 # --------------------
 841 # Checks for C headers
 842 # --------------------
 843
 844 AC_MSG_CHECKING(for GNU C library)
 845 AC_CACHE_VAL(gcc_cv_glibc,
 846 [AC_TRY_COMPILE(
 847   [#include <features.h>],[
 848 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 849 #error Not a GNU C library system
 850 #endif],
 851   [gcc_cv_glibc=yes],
 852   gcc_cv_glibc=no)])
 853 AC_MSG_RESULT($gcc_cv_glibc)
 854 if test $gcc_cv_glibc = yes; then
 855   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 856 fi
 857
 858 # Need to reject headers which give warnings, so that the -Werror bootstrap
 859 # works later. *sigh*  This needs to come before all header checks.
 860 AC_PROG_CPP_WERROR
 861
 862 AC_HEADER_STDC
 863 AC_HEADER_TIME
 864 ACX_HEADER_STRING
 865 AC_HEADER_SYS_WAIT
 866 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
 867                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 868                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 869                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 870
 871 # Check for thread headers.
 872 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 873 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 874
 875 # These tests can't be done till we know if we have limits.h.
 876 gcc_AC_C_CHAR_BIT
 877 AC_C_BIGENDIAN_CROSS
 878
 879 # --------
 880 # UNSORTED
 881 # --------
 882
 883 # Stage specific cflags for build.
 884 stage1_cflags=
 885 case $build in
 886 vax-*-*)
 887   if test x$GCC = xyes
 888   then
 889     stage1_cflags="-Wa,-J"
 890   else
 891     stage1_cflags="-J"
 892   fi
 893   ;;
 894 powerpc-*-darwin*)
 895   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 896   # sources; use -no-cpp-precomp to get to GNU cpp.
 897   # Apple's GCC has bugs in designated initializer handling, so disable
 898   # that too.
 899   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 900   ;;
 901 esac
 902 AC_SUBST(stage1_cflags)
 903
 904 # These libraries may be used by collect2.
 905 # We may need a special search path to get them linked.
 906 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 907 [save_LIBS="$LIBS"
 908 for libs in '' -lld -lmld \
 909                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 910                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 911 do
 912         LIBS="$libs"
 913         AC_TRY_LINK_FUNC(ldopen,
 914                 [gcc_cv_collect2_libs="$libs"; break])
 915 done
 916 LIBS="$save_LIBS"
 917 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 918 case $gcc_cv_collect2_libs in
 919         "none required")        ;;
 920         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 921 esac
 922 AC_SUBST(COLLECT2_LIBS)
 923
 924 # When building Ada code on Alpha, we need exc_resume which is usually in
 925 # -lexc.  So test for it.
 926 save_LIBS="$LIBS"
 927 LIBS=
 928 AC_SEARCH_LIBS(exc_resume, exc)
 929 GNAT_LIBEXC="$LIBS"
 930 LIBS="$save_LIBS"
 931 AC_SUBST(GNAT_LIBEXC)
 932
 933 # Some systems put ldexp and frexp in libm instead of libc; assume
 934 # they're both in the same place.  jcf-dump needs them.
 935 save_LIBS="$LIBS"
 936 LIBS=
 937 AC_SEARCH_LIBS(ldexp, m)
 938 LDEXP_LIB="$LIBS"
 939 LIBS="$save_LIBS"
 940 AC_SUBST(LDEXP_LIB)
 941
 942 # Use <inttypes.h> only if it exists,
 943 # doesn't clash with <sys/types.h>, and declares intmax_t.
 944 AC_MSG_CHECKING(for inttypes.h)
 945 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 946 [AC_TRY_COMPILE(
 947   [#include <sys/types.h>
 948 #include <inttypes.h>],
 949   [intmax_t i = -1;],
 950   [gcc_cv_header_inttypes_h=yes],
 951   gcc_cv_header_inttypes_h=no)])
 952 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 953 if test $gcc_cv_header_inttypes_h = yes; then
 954   AC_DEFINE(HAVE_INTTYPES_H, 1,
 955         [Define if you have a working <inttypes.h> header file.])
 956 fi
 957
 958 dnl Disabled until we have a complete test for buggy enum bitfields.
 959 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 960
 961 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 962         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 963         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
 964         scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
 965         setlocale)
 966
 967 if test x$ac_cv_func_mbstowcs = xyes; then
 968   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
 969 [    AC_TRY_RUN([#include <stdlib.h>
 970 int main()
 971 {
 972   mbstowcs(0, "", 0);
 973   return 0;
 974 }],
 975     gcc_cv_func_mbstowcs_works=yes,
 976     gcc_cv_func_mbstowcs_works=no,
 977     gcc_cv_func_mbstowcs_works=yes)])
 978   if test x$gcc_cv_func_mbstowcs_works = xyes; then
 979     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
 980   [Define this macro if mbstowcs does not crash when its
 981    first argument is NULL.])
 982   fi
 983 fi
 984
 985 AC_CHECK_TYPE(ssize_t, int)
 986
 987 # Try to determine the array type of the second argument of getgroups
 988 # for the target system (int or gid_t).
 989 AC_TYPE_GETGROUPS
 990 if test "${target}" = "${build}"; then
 991   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 992 else
 993   case "${target}" in
 994         # This condition may need some tweaking.  It should include all
 995         # targets where the array type of the second argument of getgroups
 996         # is int and the type of gid_t is not equivalent to int.
 997         *-*-sunos* | *-*-ultrix*)
 998                 TARGET_GETGROUPS_T=int
 999                 ;;
1000         *)
1001                 TARGET_GETGROUPS_T=gid_t
1002                 ;;
1003   esac
1004 fi
1005 AC_SUBST(TARGET_GETGROUPS_T)
1006
1007 gcc_AC_FUNC_PRINTF_PTR
1008 gcc_AC_FUNC_MMAP_BLACKLIST
1009
1010 case "${host}" in
1011 *-*-*vms*)
1012   # Under VMS, vfork works very differently than on Unix. The standard test
1013   # won't work, and it isn't easily adaptable. It makes more sense to
1014   # just force it.
1015   ac_cv_func_vfork_works=yes
1016   ;;
1017 esac
1018 AC_FUNC_VFORK
1019
1020 AM_ICONV
1021 # Until we have in-tree GNU iconv:
1022 LIBICONV_DEP=
1023 AC_SUBST(LIBICONV_DEP)
1024
1025 AM_LC_MESSAGES
1026
1027 AM_LANGINFO_CODESET
1028
1029 # We will need to find libiberty.h and ansidecl.h
1030 saved_CFLAGS="$CFLAGS"
1031 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1032 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
1033         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
1034         fprintf_unlocked strstr errno snprintf vasprintf \
1035         malloc realloc calloc free basename getopt clock getpagesize, , ,[
1036 #include "ansidecl.h"
1037 #include "system.h"])
1038
1039 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1040 #include "ansidecl.h"
1041 #include "system.h"
1042 #ifdef HAVE_SYS_RESOURCE_H
1043 #include <sys/resource.h>
1044 #endif
1045 ])
1046
1047 AC_TRY_COMPILE([
1048 #include "ansidecl.h"
1049 #include "system.h"
1050 #ifdef HAVE_SYS_RESOURCE_H
1051 #include <sys/resource.h>
1052 #endif
1053 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
1054 [Define to \`long' if <sys/resource.h> doesn't define.])])
1055
1056 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1057 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1058 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1059 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1060 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1061 #include "ansidecl.h"
1062 #include "system.h"
1063 #ifdef HAVE_LDFCN_H
1064 #undef FREAD
1065 #undef FWRITE
1066 #include <ldfcn.h>
1067 #endif
1068 ])
1069
1070 gcc_AC_CHECK_DECLS(times, , ,[
1071 #include "ansidecl.h"
1072 #include "system.h"
1073 #ifdef HAVE_SYS_TIMES_H
1074 #include <sys/times.h>
1075 #endif
1076 ])
1077
1078 # More time-related stuff.
1079 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1080 AC_TRY_COMPILE([
1081 #include "ansidecl.h"
1082 #include "system.h"
1083 #ifdef HAVE_SYS_TIMES_H
1084 #include <sys/times.h>
1085 #endif
1086 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
1087 if test $ac_cv_struct_tms = yes; then
1088   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1089   [Define if <sys/times.h> defines struct tms.])
1090 fi
1091
1092 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1093 # revisit after autoconf 2.50.
1094 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1095 AC_TRY_COMPILE([
1096 #include "ansidecl.h"
1097 #include "system.h"
1098 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
1099 if test $gcc_cv_type_clock_t = yes; then
1100   AC_DEFINE(HAVE_CLOCK_T, 1,
1101   [Define if <time.h> defines clock_t.])
1102 fi
1103
1104 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1105 CFLAGS="$saved_CFLAGS"
1106
1107 gcc_AC_INITFINI_ARRAY
1108
1109 # mkdir takes a single argument on some systems.
1110 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1111
1112 # File extensions
1113 manext='.1'
1114 objext='.o'
1115 AC_SUBST(manext)
1116 AC_SUBST(objext)
1117
1118 # With Setjmp/Longjmp based exception handling.
1119 AC_ARG_ENABLE(sjlj-exceptions,
1120 [  --enable-sjlj-exceptions
1121                           arrange to use setjmp/longjmp exception handling],
1122 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1123 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1124   [Define 0/1 to force the choice for exception handling model.])])
1125
1126 # For platforms with the unwind ABI which includes an unwind library,
1127 # libunwind, we can choose to use the system libunwind.
1128 AC_ARG_WITH(system-libunwind,
1129 [  --with-system-libunwind use installed libunwind])
1130
1131 # --------------------------------------------------------
1132 # Build, host, and target specific configuration fragments
1133 # --------------------------------------------------------
1134
1135 # Collect build-machine-specific information.
1136 . ${srcdir}/config.build
1137
1138 # Collect host-machine-specific information.
1139 . ${srcdir}/config.host
1140
1141 target_gtfiles=
1142
1143 # Collect target-machine-specific information.
1144 . ${srcdir}/config.gcc
1145
1146 extra_objs="${host_extra_objs} ${extra_objs}"
1147 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1148
1149 # Default the target-machine variables that were not explicitly set.
1150 if test x"$tm_file" = x
1151 then tm_file=$cpu_type/$cpu_type.h; fi
1152
1153 if test x"$extra_headers" = x
1154 then extra_headers=; fi
1155
1156 if test x$md_file = x
1157 then md_file=$cpu_type/$cpu_type.md; fi
1158
1159 if test x$out_file = x
1160 then out_file=$cpu_type/$cpu_type.c; fi
1161
1162 if test x"$tmake_file" = x
1163 then tmake_file=$cpu_type/t-$cpu_type
1164 fi
1165
1166 if test x"$dwarf2" = xyes
1167 then tm_file="$tm_file tm-dwarf2.h"
1168 fi
1169
1170 # Say what files are being used for the output code and MD file.
1171 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1172 echo "Using \`$srcdir/config/$md_file' as machine description file."
1173
1174 # If any of the xm_file variables contain nonexistent files, warn
1175 # about them and drop them.
1176
1177 bx=
1178 for x in $build_xm_file; do
1179   if    test -f $srcdir/config/$x
1180   then      bx="$bx $x"
1181   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1182   fi
1183 done
1184 build_xm_file="$bx"
1185
1186 hx=
1187 for x in $host_xm_file; do
1188   if    test -f $srcdir/config/$x
1189   then      hx="$hx $x"
1190   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1191   fi
1192 done
1193 host_xm_file="$hx"
1194
1195 tx=
1196 for x in $xm_file; do
1197   if    test -f $srcdir/config/$x
1198   then      tx="$tx $x"
1199   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1200   fi
1201 done
1202 xm_file="$tx"
1203
1204 count=a
1205 for f in $tm_file; do
1206         count=${count}x
1207 done
1208 if test $count = ax; then
1209         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1210 else
1211         echo "Using the following target machine macro files:"
1212         for f in $tm_file; do
1213                 echo "  $srcdir/config/$f"
1214         done
1215 fi
1216
1217 if test x$need_64bit_hwint = xyes; then
1218         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1219 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1220 fi
1221
1222 if test x$use_long_long_for_widest_fast_int = xyes; then
1223         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1224 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1225 efficiently supported by the host hardware.])
1226 fi
1227
1228 count=a
1229 for f in $host_xm_file; do
1230         count=${count}x
1231 done
1232 if test $count = a; then
1233         :
1234 elif test $count = ax; then
1235         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1236 else
1237         echo "Using the following host machine macro files:"
1238         for f in $host_xm_file; do
1239                 echo "  $srcdir/config/$f"
1240         done
1241 fi
1242 echo "Using ${out_host_hook_obj} for host machine hooks."
1243
1244 if test "$host_xm_file" != "$build_xm_file"; then
1245         count=a
1246         for f in $build_xm_file; do
1247                 count=${count}x
1248         done
1249         if test $count = a; then
1250                 :
1251         elif test $count = ax; then
1252                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1253         else
1254                 echo "Using the following build machine macro files:"
1255                 for f in $build_xm_file; do
1256                         echo "  $srcdir/config/$f"
1257                 done
1258         fi
1259 fi
1260
1261 # ---------
1262 # Threading
1263 # ---------
1264
1265 # Check if a valid thread package
1266 case ${enable_threads} in
1267   "" | no)
1268     # No threads
1269     target_thread_file='single'
1270     ;;
1271   yes)
1272     # default
1273     target_thread_file='single'
1274     ;;
1275   aix | dce | gnat | irix | posix | posix95 | rtems | \
1276   single | solaris | vxworks | win32 )
1277     target_thread_file=${enable_threads}
1278     ;;
1279   *)
1280     echo "${enable_threads} is an unknown thread package" 1>&2
1281     exit 1
1282     ;;
1283 esac
1284
1285 if test x${thread_file} = x; then
1286   # No thread file set by target-specific clauses in config.gcc,
1287   # so use file chosen by default logic above
1288   thread_file=${target_thread_file}
1289 fi
1290
1291 # Make gthr-default.h if we have a thread file.
1292 gthread_flags=
1293 if test $thread_file != single; then
1294   rm -f gthr-default.h
1295   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1296   gthread_flags=-DHAVE_GTHR_DEFAULT
1297 fi
1298 AC_SUBST(gthread_flags)
1299
1300 # --------
1301 # UNSORTED
1302 # --------
1303
1304 use_cxa_atexit=no
1305 if test x$enable___cxa_atexit = xyes || \
1306    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1307   if test x$host = x$target; then
1308     AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1309         [echo "__cxa_atexit can't be enabled on this target"])
1310   else
1311     # We can't check for __cxa_atexit when building a cross, so assume
1312     # it is available
1313     use_cxa_atexit=yes
1314   fi
1315   if test x$use_cxa_atexit = xyes; then
1316     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1317       [Define if you want to use __cxa_atexit, rather than atexit, to
1318       register C++ destructors for local statics and global objects.
1319       This is essential for fully standards-compliant handling of
1320       destructors, but requires __cxa_atexit in libc.])
1321   fi
1322 fi
1323
1324 # Look for a file containing extra machine modes.
1325 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1326   extra_modes_file='$(srcdir)'/config/${extra_modes}
1327   AC_SUBST(extra_modes_file)
1328   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1329   [Define to the name of a file containing a list of extra machine modes
1330    for this architecture.])
1331 fi
1332
1333 # auto-host.h is the file containing items generated by autoconf and is
1334 # the first file included by config.h.
1335 # If host=build, it is correct to have bconfig include auto-host.h
1336 # as well.  If host!=build, we are in error and need to do more
1337 # work to find out the build config parameters.
1338 if test x$host = x$build
1339 then
1340         build_auto=auto-host.h
1341 else
1342         # We create a subdir, then run autoconf in the subdir.
1343         # To prevent recursion we set host and build for the new
1344         # invocation of configure to the build for this invocation
1345         # of configure.
1346         tempdir=build.$$
1347         rm -rf $tempdir
1348         mkdir $tempdir
1349         cd $tempdir
1350         case ${srcdir} in
1351         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1352         *) realsrcdir=../${srcdir};;
1353         esac
1354         saved_CFLAGS="${CFLAGS}"
1355         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1356         ${realsrcdir}/configure \
1357                 --enable-languages=${enable_languages-all} \
1358                 --target=$target_alias --host=$build_alias --build=$build_alias
1359         CFLAGS="${saved_CFLAGS}"
1360
1361         # We just finished tests for the build machine, so rename
1362         # the file auto-build.h in the gcc directory.
1363         mv auto-host.h ../auto-build.h
1364         cd ..
1365         rm -rf $tempdir
1366         build_auto=auto-build.h
1367 fi
1368 AC_SUBST(build_subdir)
1369
1370 tm_file="${tm_file} defaults.h"
1371 tm_p_file="${tm_p_file} tm-preds.h"
1372 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1373 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1374 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1375 # put this back in temporarily.
1376 xm_file="ansidecl.h ${xm_file}"
1377
1378 # --------
1379 # UNSORTED
1380 # --------
1381
1382 # Get the version trigger filename from the toplevel
1383 if test "${with_gcc_version_trigger+set}" = set; then
1384         gcc_version_trigger=$with_gcc_version_trigger
1385 else
1386         gcc_version_trigger=${srcdir}/version.c
1387 fi
1388 changequote(,)dnl
1389 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1390 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1391
1392 # Compile in configure arguments.
1393 if test -f configargs.h ; then
1394         # Being re-configured.
1395         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1396         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1397 else
1398         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1399 fi
1400
1401 # Double all backslashes and backslash all quotes to turn
1402 # gcc_config_arguments into a C string.
1403 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1404 $gcc_config_arguments
1405 EOF
1406 gcc_config_arguments_str=`cat conftest.out`
1407 rm -f conftest.out
1408
1409 cat > configargs.h <<EOF
1410 /* Generated automatically. */
1411 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1412 static const char thread_model[] = "$thread_file";
1413
1414 static const struct {
1415   const char *name, *value;
1416 } configure_default_options[] = $configure_default_options;
1417 EOF
1418 changequote([,])dnl
1419
1420 # Internationalization
1421 PACKAGE=gcc
1422 VERSION="$gcc_version"
1423 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",
1424   [The name of this program for internationalization purposes.])
1425 AC_SUBST(PACKAGE)
1426 AC_SUBST(VERSION)
1427
1428 ZW_GNU_GETTEXT_SISTER_DIR
1429
1430 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1431 # -liconv on the link line twice.
1432 case "$LIBINTL" in *$LIBICONV*)
1433         LIBICONV= ;;
1434 esac
1435
1436 # Windows32 Registry support for specifying GCC installation paths.
1437 AC_ARG_ENABLE(win32-registry,
1438 [  --disable-win32-registry
1439                           disable lookup of installation paths in the
1440                           Registry on Windows hosts
1441   --enable-win32-registry enable registry lookup (default)
1442   --enable-win32-registry=KEY
1443                           use KEY instead of GCC version as the last portion
1444                           of the registry key],,)
1445 case $host_os in
1446         win32 | pe | cygwin* | mingw32* | uwin*)
1447 AC_MSG_CHECKING(whether windows registry support is requested)
1448 if test "x$enable_win32_registry" != xno; then
1449   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1450 [Define to 1 if installation paths should be looked up in Windows32
1451    Registry. Ignored on non windows32 hosts.])
1452   AC_MSG_RESULT(yes)
1453   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1454 else
1455   AC_MSG_RESULT(no)
1456 fi
1457
1458 # Check if user specified a different registry key.
1459 case "x${enable_win32_registry}" in
1460 x | xyes)
1461   # default.
1462   gcc_cv_win32_registry_key="$VERSION"
1463   ;;
1464 xno)
1465   # no registry lookup.
1466   gcc_cv_win32_registry_key=''
1467   ;;
1468 *)
1469   # user-specified key.
1470   gcc_cv_win32_registry_key="$enable_win32_registry"
1471   ;;
1472 esac
1473
1474 if test "x$enable_win32_registry" != xno; then
1475   AC_MSG_CHECKING(registry key on windows hosts)
1476   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1477         [Define to be the last portion of registry key on windows hosts.])
1478   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1479 fi
1480 ;;
1481 esac
1482
1483 # Get an absolute path to the GCC top-level source directory
1484 holddir=`${PWDCMD-pwd}`
1485 cd $srcdir
1486 topdir=`${PWDCMD-pwd}`
1487 cd $holddir
1488
1489 # Conditionalize the makefile for this host machine.
1490 xmake_file=
1491 for f in ${host_xmake_file}
1492 do
1493         if test -f ${srcdir}/config/$f
1494         then
1495                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1496         fi
1497 done
1498
1499 # Conditionalize the makefile for this target machine.
1500 tmake_file_=
1501 for f in ${tmake_file}
1502 do
1503         if test -f ${srcdir}/config/$f
1504         then
1505                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1506         fi
1507 done
1508 tmake_file="${tmake_file_}"
1509
1510 # If the host doesn't support symlinks, modify CC in
1511 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1512 # Otherwise, we can use "CC=$(CC)".
1513 rm -f symtest.tem
1514 case "$LN_S" in
1515         *-s*)
1516                 cc_set_by_configure="\$(CC)"
1517                 quoted_cc_set_by_configure="\$(CC)"
1518                 stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1519                 quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1520                 ;;
1521         *)
1522                 cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1523                 quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1524                 stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1525                 quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1526                 ;;
1527 esac
1528
1529 out_object_file=`basename $out_file .c`.o
1530
1531 tm_file_list=
1532 tm_include_list=
1533 for f in $tm_file; do
1534   case $f in
1535     defaults.h )
1536        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1537        tm_include_list="${tm_include_list} $f"
1538        ;;
1539     * )
1540        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1541        tm_include_list="${tm_include_list} config/$f"
1542        ;;
1543   esac
1544 done
1545
1546 tm_p_file_list=
1547 tm_p_include_list=
1548 for f in $tm_p_file; do
1549   case $f in
1550     tm-preds.h )
1551        tm_p_file_list="${tm_p_file_list} $f"
1552        tm_p_include_list="${tm_p_include_list} $f"
1553        ;;
1554     * )
1555        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1556        tm_p_include_list="${tm_p_include_list} config/$f"
1557   esac
1558 done
1559
1560 xm_file_list=
1561 xm_include_list=
1562 for f in $xm_file; do
1563   case $f in
1564     ansidecl.h )
1565        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1566        xm_include_list="${xm_include_list} $f"
1567        ;;
1568     auto-host.h )
1569        xm_file_list="${xm_file_list} $f"
1570        xm_include_list="${xm_include_list} $f"
1571        ;;
1572     * )
1573        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1574        xm_include_list="${xm_include_list} config/$f"
1575        ;;
1576   esac
1577 done
1578
1579 host_xm_file_list=
1580 host_xm_include_list=
1581 for f in $host_xm_file; do
1582   case $f in
1583     ansidecl.h )
1584        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1585        host_xm_include_list="${host_xm_include_list} $f"
1586        ;;
1587     auto-host.h )
1588        host_xm_file_list="${host_xm_file_list} $f"
1589        host_xm_include_list="${host_xm_include_list} $f"
1590        ;;
1591     * )
1592        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1593        host_xm_include_list="${host_xm_include_list} config/$f"
1594        ;;
1595   esac
1596 done
1597
1598 build_xm_file_list=
1599 for f in $build_xm_file; do
1600   case $f in
1601     ansidecl.h )
1602        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1603        build_xm_include_list="${build_xm_include_list} $f"
1604        ;;
1605     auto-build.h | auto-host.h )
1606        build_xm_file_list="${build_xm_file_list} $f"
1607        build_xm_include_list="${build_xm_include_list} $f"
1608        ;;
1609     * )
1610        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1611        build_xm_include_list="${build_xm_include_list} config/$f"
1612        ;;
1613   esac
1614 done
1615
1616 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1617 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1618 CROSS=                                          AC_SUBST(CROSS)
1619 ALL=all.internal                                AC_SUBST(ALL)
1620 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1621 if test x$host != x$target
1622 then
1623         CROSS="-DCROSS_COMPILE"
1624         ALL=all.cross
1625         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1626         case "$host","$target" in
1627         # Darwin crosses can use the host system's libraries and headers,
1628         # because of the fat library support.  Of course, it must be the
1629         # same version of Darwin on both sides.  Allow the user to
1630         # just say --target=foo-darwin without a version number to mean
1631         # "the version on this system".
1632             *-*-darwin*,*-*-darwin*)
1633                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1634                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1635                 if test $hostos = $targetos -o $targetos = darwin ; then
1636                     CROSS=
1637                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1638                     with_headers=yes
1639                 fi
1640                 ;;
1641
1642             i?86-*-*,x86_64-*-* \
1643             | powerpc*-*-*,powerpc64*-*-*)
1644                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1645         esac
1646 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1647         # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1648         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1649 fi
1650
1651 # If this is a cross-compiler that does not
1652 # have its own set of headers then define
1653 # inhibit_libc
1654
1655 # If this is using newlib, without having the headers available now,
1656 # then define inhibit_libc in LIBGCC2_CFLAGS.
1657 # This prevents libgcc2 from containing any code which requires libc
1658 # support.
1659 inhibit_libc=
1660 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1661        test x$with_newlib = xyes ; } &&
1662      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1663        inhibit_libc=-Dinhibit_libc
1664 fi
1665 AC_SUBST(inhibit_libc)
1666
1667 # When building gcc with a cross-compiler, we need to adjust things so
1668 # that the generator programs are still built with the native compiler.
1669 # Also, we cannot run fixincludes or fix-header.
1670
1671 # These are the normal (build=host) settings:
1672 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1673 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1674 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1675
1676 # Possibly disable fixproto, on a per-target basis.
1677 case ${use_fixproto} in
1678   no)
1679     STMP_FIXPROTO=
1680     ;;
1681   yes)
1682     STMP_FIXPROTO=stmp-fixproto
1683     ;;
1684 esac
1685 AC_SUBST(STMP_FIXPROTO)
1686
1687 # And these apply if build != host, or we are generating coverage data
1688 if test x$build != x$host || test "x$coverage_flags" != x
1689 then
1690     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1691
1692     if test "x$TARGET_SYSTEM_ROOT" = x; then
1693         if [ "x$STMP_FIXPROTO" != x ] ; then
1694           STMP_FIXPROTO=stmp-install-fixproto
1695         fi
1696     fi
1697 fi
1698
1699 # Expand extra_headers to include complete path.
1700 # This substitutes for lots of t-* files.
1701 extra_headers_list=
1702 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1703 for file in ${extra_headers} ; do
1704   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1705 done
1706
1707 # Define collect2 in Makefile.
1708 case $host_can_use_collect2 in
1709   no) collect2= ;;
1710   *) collect2='collect2$(exeext)' ;;
1711 esac
1712 AC_SUBST([collect2])
1713
1714 # Add a definition of USE_COLLECT2 if system wants one.
1715 case $use_collect2 in
1716   no) use_collect2= ;;
1717   "") ;;
1718   *)
1719     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1720     xm_defines="${xm_defines} USE_COLLECT2"
1721     case $host_can_use_collect2 in
1722       no)
1723         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1724         ;;
1725     esac
1726     ;;
1727 esac
1728
1729 # ---------------------------
1730 # Assembler & linker features
1731 # ---------------------------
1732
1733 # Identify the assembler which will work hand-in-glove with the newly
1734 # built GCC, so that we can examine its features.  This is the assembler
1735 # which will be driven by the driver program.
1736 #
1737 # If build != host, and we aren't building gas in-tree, we identify a
1738 # build->target assembler and hope that it will have the same features
1739 # as the host->target assembler we'll be using.
1740 AC_MSG_CHECKING(what assembler to use)
1741 in_tree_gas=no
1742 gcc_cv_as=
1743 gcc_cv_gas_major_version=
1744 gcc_cv_gas_minor_version=
1745 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1746 if test -x "$DEFAULT_ASSEMBLER"; then
1747         gcc_cv_as="$DEFAULT_ASSEMBLER"
1748 elif test -x as$build_exeext; then
1749         # Build using assembler in the current directory.
1750         gcc_cv_as=./as$build_exeext
1751 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1752      && test -f ../gas/Makefile \
1753      && test x$build = x$host; then
1754   # Single tree build which includes gas.  We want to prefer it
1755   # over whatever linker top-level may have detected, since
1756   # we'll use what we're building after installation anyway.
1757   in_tree_gas=yes
1758   _gcc_COMPUTE_GAS_VERSION
1759   rm -f as$build_exeext
1760   $LN_S ../gas/as-new$build_exeext as$build_exeext 2>/dev/null
1761   in_tree_gas_is_elf=no
1762   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1763      || (grep 'obj_format = multi' ../gas/Makefile \
1764          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1765   then
1766     in_tree_gas_is_elf=yes
1767   fi
1768 m4_pattern_allow([AS_FOR_TARGET])dnl
1769 elif test -x "$AS_FOR_TARGET"; then
1770         gcc_cv_as="$AS_FOR_TARGET"
1771 elif test -x "$AS" && test x$host = x$target; then
1772         gcc_cv_as="$AS"
1773 fi
1774
1775 if test "x$gcc_cv_as" = x; then
1776         # Search the same directories that the installed compiler will
1777         # search.  Else we may find the wrong assembler and lose.  If we
1778         # do not find a suitable assembler binary, then try the user's
1779         # path.
1780         #
1781         # Also note we have to check MD_EXEC_PREFIX before checking the
1782         # user's path.  Unfortunately, there is no good way to get at the
1783         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1784         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1785         # to be fixed as part of the make/configure rewrite too.
1786
1787         if test "x$exec_prefix" = xNONE; then
1788                 if test "x$prefix" = xNONE; then
1789                         test_prefix=/usr/local
1790                 else
1791                         test_prefix=$prefix
1792                 fi
1793         else
1794                 test_prefix=$exec_prefix
1795         fi
1796
1797         # If the loop below does not find an assembler, then use whatever
1798         # one we can find in the users's path.
1799         # user's path.
1800         if test "x$program_prefix" != xNONE; then
1801                 gcc_cv_as=${program_prefix}as$build_exeext
1802         else
1803                 gcc_cv_as=`echo as | sed "${program_transform_name}"`$build_exeext
1804         fi
1805
1806         if test x$host = x$build; then
1807             test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1808                        $test_prefix/libexec/gcc/$target_noncanonical \
1809                        /usr/lib/gcc/$target_noncanonical/$gcc_version \
1810                        /usr/lib/gcc/$target_noncanonical \
1811                        $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1812                        $test_prefix/$target_noncanonical/bin"
1813         else
1814             test_dirs=
1815         fi
1816
1817         if test x$host = x$target; then
1818             test_dirs="$test_dirs \
1819                    /usr/libexec \
1820                    /usr/ccs/gcc \
1821                    /usr/ccs/bin \
1822                    /udk/usr/ccs/bin \
1823                    /bsd43/usr/lib/cmplrs/cc \
1824                    /usr/cross64/usr/bin \
1825                    /usr/lib/cmplrs/cc \
1826                    /sysv/usr/lib/cmplrs/cc \
1827                    /svr4/usr/lib/cmplrs/cc \
1828                    /usr/bin"
1829         fi
1830
1831         for dir in $test_dirs; do
1832                 if test -x $dir/as$build_exeext; then
1833                         gcc_cv_as=$dir/as$build_exeext
1834                         break;
1835                 fi
1836         done
1837 fi
1838 case $in_tree_gas in
1839   yes)
1840     AC_MSG_RESULT("newly built gas")
1841     ;;
1842   no)
1843     AC_MSG_RESULT($gcc_cv_as)
1844     ;;
1845 esac
1846
1847 # Identify the linker which will work hand-in-glove with the newly
1848 # built GCC, so that we can examine its features.  This is the linker
1849 # which will be driven by the driver program.
1850 #
1851 # If build != host, and we aren't building gas in-tree, we identify a
1852 # build->target linker and hope that it will have the same features
1853 # as the host->target linker we'll be using.
1854 AC_MSG_CHECKING(what linker to use)
1855 in_tree_ld=no
1856 gcc_cv_ld=
1857 gcc_cv_gld_major_version=
1858 gcc_cv_gld_minor_version=
1859 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1860 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1861 if test -x "$DEFAULT_LINKER"; then
1862         gcc_cv_ld="$DEFAULT_LINKER"
1863 elif test -x collect-ld$build_exeext; then
1864         # Build using linker in the current directory.
1865         gcc_cv_ld=./collect-ld$build_exeext
1866 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1867      && test -f ../ld/Makefile \
1868      && test x$build = x$host; then
1869         # Single tree build which includes ld.  We want to prefer it
1870         # over whatever linker top-level may have detected, since
1871         # we'll use what we're building after installation anyway.
1872         in_tree_ld=yes
1873         in_tree_ld_is_elf=no
1874         if (grep 'EMUL = .*elf' ../ld/Makefile \
1875             || grep 'EMUL = .*linux' ../ld/Makefile \
1876             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1877           in_tree_ld_is_elf=yes
1878         fi
1879         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
1880         do
1881 changequote(,)dnl
1882                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1883 changequote([,])dnl
1884                 if test x$gcc_cv_gld_version != x; then
1885                         break
1886                 fi
1887         done
1888 changequote(,)dnl
1889         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1890         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1891 changequote([,])dnl
1892         rm -f collect-ld$build_exeext
1893         $LN_S ../ld/ld-new$build_exeext collect-ld$build_exeext 2>/dev/null
1894 elif test -x "$LD_FOR_TARGET"; then
1895         gcc_cv_ld="$LD_FOR_TARGET"
1896 elif test -x "$LD" && test x$host = x$target; then
1897         gcc_cv_ld="$LD"
1898 fi
1899
1900 if test "x$gcc_cv_ld" = x; then
1901         # Search the same directories that the installed compiler will
1902         # search.  Else we may find the wrong linker and lose.  If we
1903         # do not find a suitable linker binary, then try the user's
1904         # path.
1905         #
1906         # Also note we have to check MD_EXEC_PREFIX before checking the
1907         # user's path.  Unfortunately, there is no good way to get at the
1908         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1909         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1910         # to be fixed as part of the make/configure rewrite too.
1911
1912         if test "x$exec_prefix" = xNONE; then
1913                 if test "x$prefix" = xNONE; then
1914                         test_prefix=/usr/local
1915                 else
1916                         test_prefix=$prefix
1917                 fi
1918         else
1919                 test_prefix=$exec_prefix
1920         fi
1921
1922         # If the loop below does not find an linker, then use whatever
1923         # one we can find in the users's path.
1924         # user's path.
1925         if test "x$program_prefix" != xNONE; then
1926                 gcc_cv_ld=${program_prefix}ld$build_exeext
1927         else
1928                 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$build_exeext
1929         fi
1930
1931         if test x$host = x$build; then
1932             test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1933                        $test_prefix/libexec/gcc/$target_noncanonical \
1934                        /usr/lib/gcc/$target_noncanonical/$gcc_version \
1935                        /usr/lib/gcc/$target_noncanonical \
1936                        $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1937                        $test_prefix/$target_noncanonical/bin"
1938         else
1939             test_dirs=
1940         fi
1941
1942         if test x$host = x$target; then
1943             test_dirs="$test_dirs \
1944                    /usr/libexec \
1945                    /usr/ccs/gcc \
1946                    /usr/ccs/bin \
1947                    /udk/usr/ccs/bin \
1948                    /bsd43/usr/lib/cmplrs/cc \
1949                    /usr/cross64/usr/bin \
1950                    /usr/lib/cmplrs/cc \
1951                    /sysv/usr/lib/cmplrs/cc \
1952                    /svr4/usr/lib/cmplrs/cc \
1953                    /usr/bin"
1954         fi
1955
1956         for dir in $test_dirs; do
1957                 if test -x $dir/ld$build_exeext; then
1958                         gcc_cv_ld=$dir/ld$build_exeext
1959                         break;
1960                 fi
1961         done
1962 fi
1963 case $in_tree_ld in
1964   yes)
1965     AC_MSG_RESULT("newly built ld")
1966     ;;
1967   no)
1968     AC_MSG_RESULT($gcc_cv_ld)
1969     ;;
1970 esac
1971
1972 # Figure out what nm we will be using.
1973 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1974 AC_MSG_CHECKING(what nm to use)
1975 in_tree_nm=no
1976 if test -x nm$build_exeext; then
1977         gcc_cv_nm=./nm$build_exeext
1978 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1979      && test -f ../binutils/Makefile; then
1980         # Single tree build which includes binutils.
1981         in_tree_nm=yes
1982         gcc_cv_nm=./nm$build_exeext
1983         rm -f nm$build_exeext
1984         $LN_S ../binutils/nm-new$build_exeext nm$build_exeext 2>/dev/null
1985 elif test "x$program_prefix" != xNONE; then
1986         gcc_cv_nm=${program_prefix}nm$build_exeext
1987 else
1988         gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$build_exeext
1989 fi
1990 case $in_tree_nm in
1991   yes) AC_MSG_RESULT("newly built nm") ;;
1992   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1993 esac
1994
1995 # Figure out what objdump we will be using.
1996 AC_MSG_CHECKING(what objdump to use)
1997 in_tree_objdump=no
1998 if test -x objdump$build_exeext; then
1999         gcc_cv_objdump=./objdump$build_exeext
2000 elif test -f $gcc_cv_binutils_srcdir/configure.in \
2001      && test -f ../binutils/Makefile; then
2002         # Single tree build which includes binutils.
2003         in_tree_objdump=yes
2004         gcc_cv_objdump=./objdump$build_exeext
2005         rm -f objdump$build_exeext
2006         $LN_S ../binutils/objdump$build_exeext objdump$build_exeext 2>/dev/null
2007 elif test "x$program_prefix" != xNONE; then
2008         gcc_cv_objdump=${program_prefix}objdump$build_exeext
2009 else
2010         gcc_cv_objdump=`echo objdump | \
2011                 sed "${program_transform_name}"`$build_exeext
2012 fi
2013 case $in_tree_objdump in
2014   yes) AC_MSG_RESULT("newly built objdump") ;;
2015   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
2016 esac
2017
2018 # Figure out what assembler alignment features are present.
2019 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2020  [2,6,0],,
2021 [.balign 4
2022 .p2align 2],,
2023 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2024   [Define if your assembler supports .balign and .p2align.])])
2025
2026 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2027  [2,8,0],,
2028  [.p2align 4,,7],,
2029 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2030   [Define if your assembler supports specifying the maximum number
2031    of bytes to skip when using the GAS .p2align command.])])
2032
2033 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2034  [elf,2,9,0],,
2035  [conftest_label1: .word 0
2036 .subsection -1
2037 conftest_label2: .word 0
2038 .previous],
2039  [if test x$gcc_cv_nm != x; then
2040     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2041     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2042     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2043     then :
2044     else gcc_cv_as_subsection_m1=yes
2045     fi
2046     rm -f conftest.nm1 conftest.nm2
2047   fi],
2048  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2049   [Define if your assembler supports .subsection and .subsection -1 starts
2050    emitting at the beginning of your section.])])
2051
2052 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2053  [2,2,0],,
2054  [      .weak foobar],,
2055 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2056
2057 # .hidden needs to be supported in both the assembler and the linker,
2058 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2059 # This is irritatingly difficult to feature test for; we have to check the
2060 # date string after the version number.  If we've got an in-tree
2061 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2062 # to be safe.
2063 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2064 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2065  [elf,2,13,0],,
2066 [       .hidden foobar
2067 foobar:])
2068
2069 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2070 [if test $in_tree_ld = yes ; then
2071   gcc_cv_ld_hidden=no
2072   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 \
2073      && test $in_tree_ld_is_elf = yes; then
2074      gcc_cv_ld_hidden=yes
2075   fi
2076 else
2077   gcc_cv_ld_hidden=yes
2078   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2079   if echo "$ld_ver" | grep GNU > /dev/null; then
2080 changequote(,)dnl
2081     ld_vers=`echo $ld_ver | sed -n \
2082         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2083         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2084         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2085         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)[  ].*$,\1,p' \
2086         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[     ].*$,\1,p' \
2087         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[        ].*$,\1,p'`
2088     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'`
2089     if test 0"$ld_date" -lt 20020404; then
2090       if test -n "$ld_date"; then
2091         # If there was date string, but was earlier than 2002-04-04, fail
2092         gcc_cv_ld_hidden=no
2093       elif test -z "$ld_vers"; then
2094         # If there was no date string nor ld version number, something is wrong
2095         gcc_cv_ld_hidden=no
2096       else
2097         ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2098         ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2099         ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2100         test -z "$ld_vers_patch" && ld_vers_patch=0
2101         if test "$ld_vers_major" -lt 2; then
2102           gcc_cv_ld_hidden=no
2103         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2104           gcc_cv_ld_hidden="no"
2105         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2106           gcc_cv_ld_hidden=no
2107         fi
2108       fi
2109 changequote([,])dnl
2110     fi
2111   else
2112     case "${target}" in
2113       hppa64*-*-hpux* | ia64*-*-hpux*)
2114         gcc_cv_ld_hidden=yes
2115         ;;
2116       *)
2117         gcc_cv_ld_hidden=no
2118         ;;
2119     esac
2120   fi
2121 fi])
2122 libgcc_visibility=no
2123 AC_SUBST(libgcc_visibility)
2124 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2125   libgcc_visibility=yes
2126   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2127   [Define if your assembler and linker support .hidden.])
2128 fi
2129
2130 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2131 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2132   [elf,2,11,0],,
2133 [       .data
2134         .uleb128 L2 - L1
2135 L1:
2136         .uleb128 1280
2137         .sleb128 -1010
2138 L2:],
2139  [# GAS versions before 2.11 do not support uleb128,
2140   # despite appearing to.
2141   # ??? There exists an elf-specific test that will crash
2142   # the assembler.  Perhaps it's better to figure out whether
2143   # arbitrary sections are supported and try the test.
2144   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2145   if echo "$as_ver" | grep GNU > /dev/null; then
2146 changequote(,)dnl
2147     as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2148     as_major=`echo $as_ver | sed 's/\..*//'`
2149     as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2150 changequote([,])dnl
2151     if test $as_major -eq 2 && test $as_minor -lt 11
2152     then :
2153     else gcc_cv_as_leb128=yes
2154     fi
2155   fi],
2156   [AC_DEFINE(HAVE_AS_LEB128, 1,
2157     [Define if your assembler supports .sleb128 and .uleb128.])])
2158
2159 # GAS versions up to and including 2.11.0 may mis-optimize
2160 # .eh_frame data.
2161 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2162   [elf,2,12,0],,
2163 [       .text
2164 .LFB1:
2165         .4byte  0
2166 .L1:
2167         .4byte  0
2168 .LFE1:
2169         .section        .eh_frame,"aw",@progbits
2170 __FRAME_BEGIN__:
2171         .4byte  .LECIE1-.LSCIE1
2172 .LSCIE1:
2173         .4byte  0x0
2174         .byte   0x1
2175         .ascii "z\0"
2176         .byte   0x1
2177         .byte   0x78
2178         .byte   0x1a
2179         .byte   0x0
2180         .byte   0x4
2181         .4byte  1
2182         .p2align 1
2183 .LECIE1:
2184 .LSFDE1:
2185         .4byte  .LEFDE1-.LASFDE1
2186 .LASFDE1:
2187         .4byte  .LASFDE1-__FRAME_BEGIN__
2188         .4byte  .LFB1
2189         .4byte  .LFE1-.LFB1
2190         .byte   0x4
2191         .4byte  .LFE1-.LFB1
2192         .byte   0x4
2193         .4byte  .L1-.LFB1
2194 .LEFDE1:],
2195 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2196 cat > conftest.lit <<EOF
2197  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2198  0010 01000000 12000000 18000000 00000000  ................
2199  0020 08000000 04080000 0044               .........D      @&t@
2200 EOF
2201 cat > conftest.big <<EOF
2202  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2203  0010 00000001 00000012 00000018 00000000  ................
2204  0020 00000008 04000000 0844               .........D      @&t@
2205 EOF
2206   # If the assembler didn't choke, and we can objdump,
2207   # and we got the correct data, then succeed.
2208   if test x$gcc_cv_objdump != x \
2209   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2210      | tail -3 > conftest.got \
2211   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2212     || cmp conftest.big conftest.got > /dev/null 2>&1; }
2213   then
2214     gcc_cv_as_eh_frame=yes
2215   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2216     gcc_cv_as_eh_frame=buggy
2217   else
2218     # Uh oh, what do we do now?
2219     gcc_cv_as_eh_frame=no
2220   fi])
2221
2222 if test $gcc_cv_as_eh_frame = buggy; then
2223   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2224   [Define if your assembler mis-optimizes .eh_frame data.])
2225 fi
2226
2227 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2228  [elf,2,12,0], [--fatal-warnings],
2229  [.section .rodata.str, "aMS", @progbits, 1])
2230 if test $gcc_cv_as_shf_merge = no; then
2231   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2232     [elf,2,12,0], [--fatal-warnings],
2233     [.section .rodata.str, "aMS", %progbits, 1])
2234 fi
2235 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2236   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2237 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2238
2239 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2240  [elf,2,15,91], [--fatal-warnings],
2241  [.section .text,"axG",@progbits,.foo,comdat])
2242 if test $gcc_cv_as_comdat_group = yes; then
2243   gcc_cv_as_comdat_group_percent=no
2244 else
2245  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2246    [elf,2,15,91], [--fatal-warnings],
2247    [.section .text,"axG",%progbits,.foo,comdat])
2248 fi
2249 AC_DEFINE_UNQUOTED(HAVE_GAS_COMDAT_GROUP,
2250   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2251 [Define 0/1 if your assembler supports COMDAT group.])
2252
2253 # Thread-local storage - the check is heavily parametrized.
2254 conftest_s=
2255 tls_first_major=
2256 tls_first_minor=
2257 tls_as_opt=
2258 case "$target" in
2259 changequote(,)dnl
2260   alpha*-*-*)
2261     conftest_s='
2262         .section ".tdata","awT",@progbits
2263 foo:    .long   25
2264         .text
2265         ldq     $27,__tls_get_addr($29)         !literal!1
2266         lda     $16,foo($29)                    !tlsgd!1
2267         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2268         ldq     $27,__tls_get_addr($29)         !literal!2
2269         lda     $16,foo($29)                    !tlsldm!2
2270         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2271         ldq     $1,foo($29)                     !gotdtprel
2272         ldah    $2,foo($29)                     !dtprelhi
2273         lda     $3,foo($2)                      !dtprello
2274         lda     $4,foo($29)                     !dtprel
2275         ldq     $1,foo($29)                     !gottprel
2276         ldah    $2,foo($29)                     !tprelhi
2277         lda     $3,foo($2)                      !tprello
2278         lda     $4,foo($29)                     !tprel'
2279         tls_first_major=2
2280         tls_first_minor=13
2281         tls_as_opt=--fatal-warnings
2282         ;;
2283   i[34567]86-*-*)
2284     conftest_s='
2285         .section ".tdata","awT",@progbits
2286 foo:    .long   25
2287         .text
2288         movl    %gs:0, %eax
2289         leal    foo@TLSGD(,%ebx,1), %eax
2290         leal    foo@TLSLDM(%ebx), %eax
2291         leal    foo@DTPOFF(%eax), %edx
2292         movl    foo@GOTTPOFF(%ebx), %eax
2293         subl    foo@GOTTPOFF(%ebx), %eax
2294         addl    foo@GOTNTPOFF(%ebx), %eax
2295         movl    foo@INDNTPOFF, %eax
2296         movl    $foo@TPOFF, %eax
2297         subl    $foo@TPOFF, %eax
2298         leal    foo@NTPOFF(%ecx), %eax'
2299         tls_first_major=2
2300         tls_first_minor=14
2301         tls_as_opt=--fatal-warnings
2302         ;;
2303   x86_64-*-*)
2304     conftest_s='
2305         .section ".tdata","awT",@progbits
2306 foo:    .long   25
2307         .text
2308         movq    %fs:0, %rax
2309         leaq    foo@TLSGD(%rip), %rdi
2310         leaq    foo@TLSLD(%rip), %rdi
2311         leaq    foo@DTPOFF(%rax), %rdx
2312         movq    foo@GOTTPOFF(%rip), %rax
2313         movq    $foo@TPOFF, %rax'
2314         tls_first_major=2
2315         tls_first_minor=14
2316         tls_as_opt=--fatal-warnings
2317         ;;
2318   ia64-*-*)
2319     conftest_s='
2320         .section ".tdata","awT",@progbits
2321 foo:    data8   25
2322         .text
2323         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2324         addl    r17 = @ltoff(@dtprel(foo#)), gp
2325         addl    r18 = @ltoff(@tprel(foo#)), gp
2326         addl    r19 = @dtprel(foo#), gp
2327         adds    r21 = @dtprel(foo#), r13
2328         movl    r23 = @dtprel(foo#)
2329         addl    r20 = @tprel(foo#), gp
2330         adds    r22 = @tprel(foo#), r13
2331         movl    r24 = @tprel(foo#)'
2332         tls_first_major=2
2333         tls_first_minor=13
2334         tls_as_opt=--fatal-warnings
2335         ;;
2336   powerpc-*-*)
2337     conftest_s='
2338         .section ".tdata","awT",@progbits
2339         .align 2
2340 ld0:    .space 4
2341 ld1:    .space 4
2342 x1:     .space 4
2343 x2:     .space 4
2344 x3:     .space 4
2345         .text
2346         addi 3,31,ld0@got@tlsgd
2347         bl __tls_get_addr
2348         addi 3,31,x1@got@tlsld
2349         bl __tls_get_addr
2350         addi 9,3,x1@dtprel
2351         addis 9,3,x2@dtprel@ha
2352         addi 9,9,x2@dtprel@l
2353         lwz 9,x3@got@tprel(31)
2354         add 9,9,x@tls
2355         addi 9,2,x1@tprel
2356         addis 9,2,x2@tprel@ha
2357         addi 9,9,x2@tprel@l'
2358         tls_first_major=2
2359         tls_first_minor=14
2360         tls_as_opt="-a32 --fatal-warnings"
2361         ;;
2362   powerpc64-*-*)
2363     conftest_s='
2364         .section ".tdata","awT",@progbits
2365         .align 3
2366 ld0:    .space 8
2367 ld1:    .space 8
2368 x1:     .space 8
2369 x2:     .space 8
2370 x3:     .space 8
2371         .text
2372         addi 3,2,ld0@got@tlsgd
2373         bl .__tls_get_addr
2374         nop
2375         addi 3,2,ld1@toc
2376         bl .__tls_get_addr
2377         nop
2378         addi 3,2,x1@got@tlsld
2379         bl .__tls_get_addr
2380         nop
2381         addi 9,3,x1@dtprel
2382         bl .__tls_get_addr
2383         nop
2384         addis 9,3,x2@dtprel@ha
2385         addi 9,9,x2@dtprel@l
2386         bl .__tls_get_addr
2387         nop
2388         ld 9,x3@got@dtprel(2)
2389         add 9,9,3
2390         bl .__tls_get_addr
2391         nop'
2392         tls_first_major=2
2393         tls_first_minor=14
2394         tls_as_opt="-a64 --fatal-warnings"
2395         ;;
2396   s390-*-*)
2397     conftest_s='
2398         .section ".tdata","awT",@progbits
2399 foo:    .long   25
2400         .text
2401         .long   foo@TLSGD
2402         .long   foo@TLSLDM
2403         .long   foo@DTPOFF
2404         .long   foo@NTPOFF
2405         .long   foo@GOTNTPOFF
2406         .long   foo@INDNTPOFF
2407         l       %r1,foo@GOTNTPOFF(%r12)
2408         l       %r1,0(%r1):tls_load:foo
2409         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2410         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2411         tls_first_major=2
2412         tls_first_minor=14
2413         tls_as_opt="-m31 --fatal-warnings"
2414         ;;
2415   s390x-*-*)
2416     conftest_s='
2417         .section ".tdata","awT",@progbits
2418 foo:    .long   25
2419         .text
2420         .quad   foo@TLSGD
2421         .quad   foo@TLSLDM
2422         .quad   foo@DTPOFF
2423         .quad   foo@NTPOFF
2424         .quad   foo@GOTNTPOFF
2425         lg      %r1,foo@GOTNTPOFF(%r12)
2426         larl    %r1,foo@INDNTPOFF
2427         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2428         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2429         tls_first_major=2
2430         tls_first_minor=14
2431         tls_as_opt="-m64 -Aesame --fatal-warnings"
2432         ;;
2433   sh-*-* | sh[34]-*-*)
2434     conftest_s='
2435         .section ".tdata","awT",@progbits
2436 foo:    .long   25
2437         .text
2438         .long   foo@TLSGD
2439         .long   foo@TLSLDM
2440         .long   foo@DTPOFF
2441         .long   foo@GOTTPOFF
2442         .long   foo@TPOFF'
2443         tls_first_major=2
2444         tls_first_minor=13
2445         tls_as_opt=--fatal-warnings
2446         ;;
2447   sparc*-*-*)
2448     case "$target" in
2449       sparc*-sun-solaris2.*)
2450         on_solaris=yes
2451         ;;
2452       *)
2453         on_solaris=no
2454         ;;
2455     esac
2456     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2457       conftest_s='
2458         .section ".tdata",#alloc,#write,#tls
2459 foo:    .long   25
2460         .text
2461         sethi   %tgd_hi22(foo), %o0
2462         add     %o0, %tgd_lo10(foo), %o1
2463         add     %l7, %o1, %o0, %tgd_add(foo)
2464         call    __tls_get_addr, %tgd_call(foo)
2465         sethi   %tldm_hi22(foo), %l1
2466         add     %l1, %tldm_lo10(foo), %l2
2467         add     %l7, %l2, %o0, %tldm_add(foo)
2468         call    __tls_get_addr, %tldm_call(foo)
2469         sethi   %tldo_hix22(foo), %l3
2470         xor     %l3, %tldo_lox10(foo), %l4
2471         add     %o0, %l4, %l5, %tldo_add(foo)
2472         sethi   %tie_hi22(foo), %o3
2473         add     %o3, %tie_lo10(foo), %o3
2474         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2475         add     %g7, %o2, %o4, %tie_add(foo)
2476         sethi   %tle_hix22(foo), %l1
2477         xor     %l1, %tle_lox10(foo), %o5
2478         ld      [%g7 + %o5], %o1'
2479         tls_first_major=0
2480         tls_first_minor=0
2481     else
2482       conftest_s='
2483         .section ".tdata","awT",@progbits
2484 foo:    .long   25
2485         .text
2486         sethi   %tgd_hi22(foo), %o0
2487         add     %o0, %tgd_lo10(foo), %o1
2488         add     %l7, %o1, %o0, %tgd_add(foo)
2489         call    __tls_get_addr, %tgd_call(foo)
2490         sethi   %tldm_hi22(foo), %l1
2491         add     %l1, %tldm_lo10(foo), %l2
2492         add     %l7, %l2, %o0, %tldm_add(foo)
2493         call    __tls_get_addr, %tldm_call(foo)
2494         sethi   %tldo_hix22(foo), %l3
2495         xor     %l3, %tldo_lox10(foo), %l4
2496         add     %o0, %l4, %l5, %tldo_add(foo)
2497         sethi   %tie_hi22(foo), %o3
2498         add     %o3, %tie_lo10(foo), %o3
2499         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2500         add     %g7, %o2, %o4, %tie_add(foo)
2501         sethi   %tle_hix22(foo), %l1
2502         xor     %l1, %tle_lox10(foo), %o5
2503         ld      [%g7 + %o5], %o1'
2504         tls_first_major=2
2505         tls_first_minor=14
2506         tls_as_opt="-32 --fatal-warnings"
2507       fi
2508         ;;
2509 changequote([,])dnl
2510 esac
2511 if test -z "$tls_first_major"; then
2512   : # If we don't have a check, assume no support.
2513 else
2514   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2515   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2516   [AC_DEFINE(HAVE_AS_TLS, 1,
2517             [Define if your assembler supports thread-local storage.])])
2518 fi
2519
2520 # Target-specific assembler checks.
2521
2522 if test x"$demangler_in_ld" = xyes; then
2523   AC_MSG_CHECKING(linker --demangle support)
2524   gcc_cv_ld_demangle=no
2525   if test $in_tree_ld = yes; then
2526     if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 14 -o "$gcc_cv_gld_major_version" -gt 2; then \
2527       gcc_cv_ld_demangle=yes
2528     fi
2529   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2530     # Check if the GNU linker supports --demangle option
2531     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2532       gcc_cv_ld_demangle=yes
2533     fi
2534   fi
2535   if test x"$gcc_cv_ld_demangle" = xyes; then
2536     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2537 [Define if your linker supports --demangle option.])
2538   fi
2539   AC_MSG_RESULT($gcc_cv_ld_demangle)
2540 fi
2541
2542 case "$target" in
2543   # All TARGET_ABI_OSF targets.
2544   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2545     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2546         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2547 [       .set nomacro
2548         .text
2549         extbl   $3, $2, $3      !lituse_bytoff!1
2550         ldq     $2, a($29)      !literal!1
2551         ldq     $4, b($29)      !literal!2
2552         ldq_u   $3, 0($2)       !lituse_base!1
2553         ldq     $27, f($29)     !literal!5
2554         jsr     $26, ($27), f   !lituse_jsr!5
2555         ldah    $29, 0($26)     !gpdisp!3
2556         lda     $0, c($29)      !gprel
2557         ldah    $1, d($29)      !gprelhigh
2558         lda     $1, d($1)       !gprellow
2559         lda     $29, 0($29)     !gpdisp!3],,
2560     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2561   [Define if your assembler supports explicit relocations.])])
2562     ;;
2563
2564   cris-*-*)
2565     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2566       gcc_cv_as_cris_no_mul_bug,[2,15,91],
2567       [-no-mul-bug-abort], [.text],,
2568       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2569                 [Define if your assembler supports the -no-mul-bug-abort option.])])
2570     ;;
2571
2572   sparc*-*-*)
2573     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2574       [.register %g2, #scratch],,
2575       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2576                 [Define if your assembler supports .register.])])
2577
2578     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2579       [-relax], [.text],,
2580       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2581                 [Define if your assembler supports -relax option.])])
2582
2583     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2584       gcc_cv_as_sparc_ua_pcrel,,
2585       [-K PIC],
2586 [.text
2587 foo:
2588         nop
2589 .data
2590 .align 4
2591 .byte 0
2592 .uaword %r_disp32(foo)],
2593       [if test x$gcc_cv_ld != x \
2594        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2595          gcc_cv_as_sparc_ua_pcrel=yes
2596        fi
2597        rm -f conftest],
2598       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2599                 [Define if your assembler and linker support unaligned PC relative relocs.])
2600
2601       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2602         gcc_cv_as_sparc_ua_pcrel_hidden,,
2603         [-K PIC],
2604 [.data
2605 .align 4
2606 .byte 0x31
2607 .uaword %r_disp32(foo)
2608 .byte 0x32, 0x33, 0x34
2609 .global foo
2610 .hidden foo
2611 foo:
2612 .skip 4],
2613         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2614          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2615          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2616             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2617             if $gcc_cv_objdump -R conftest 2> /dev/null \
2618                | grep 'DISP32' > /dev/null 2>&1; then
2619                 :
2620             else
2621                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2622             fi
2623          fi
2624          rm -f conftest],
2625          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2626                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2627     ]) # unaligned pcrel relocs
2628
2629     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2630       gcc_cv_as_sparc_offsetable_lo10,,
2631       [-xarch=v9],
2632 [.text
2633         or %g1, %lo(ab) + 12, %g1
2634         or %g1, %lo(ab + 12), %g1],
2635       [if test x$gcc_cv_objdump != x \
2636        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2637           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2638          gcc_cv_as_offsetable_lo10=yes
2639        fi],
2640        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2641                  [Define if your assembler supports offsetable %lo().])])
2642     ;;
2643
2644 changequote(,)dnl
2645   i[34567]86-*-* | x86_64-*-*)
2646 changequote([,])dnl
2647     case $target_os in
2648       cygwin* | pe | mingw32*)
2649         # Used for DWARF 2 in PE
2650         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2651           gcc_cv_as_ix86_pe_secrel32,
2652           [2,15,91],,
2653 [.text
2654 foo:    nop
2655 .data
2656         .secrel32 foo],
2657           [if test x$gcc_cv_ld != x \
2658            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2659              gcc_cv_as_ix86_pe_secrel32=yes
2660            fi
2661            rm -f conftest],
2662           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2663             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2664         ;;
2665     esac
2666
2667     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2668        gcc_cv_as_ix86_filds_fists,
2669       [2,9,0],, [filds mem; fists mem],,
2670       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2671         [Define if your assembler uses the new HImode fild and fist notation.])])
2672
2673     gcc_GAS_CHECK_FEATURE([cmov syntax],
2674       gcc_cv_as_ix86_cmov_sun_syntax,,,
2675       [cmovl.l %edx, %eax],,
2676       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2677         [Define if your assembler supports the Sun syntax for cmov.])])
2678
2679     # This one is used unconditionally by i386.[ch]; it is to be defined
2680     # to 1 if the feature is present, 0 otherwise.
2681     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2682         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2683 [       .text
2684 .L0:
2685         nop
2686         .data
2687         .long .L0@GOTOFF])
2688     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2689       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2690       [Define true if the assembler supports '.long foo@GOTOFF'.])
2691     ;;
2692
2693   ia64*-*-*)
2694     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2695         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2696 [       .text
2697         addl r15 = @ltoffx(x#), gp
2698         ;;
2699         ld8.mov r16 = [[r15]], x#],,
2700     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2701           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2702
2703     ;;
2704
2705   powerpc*-*-*)
2706     case $target in
2707       *-*-aix*) conftest_s='    .csect .text[[PR]]
2708         mfcr 3,128';;
2709       *-*-darwin*)
2710         gcc_GAS_CHECK_FEATURE([.machine directive support],
2711           gcc_cv_as_machine_directive,,,
2712           [     .machine ppc7400])
2713         if test x$gcc_cv_as_machine_directive != xyes; then
2714           echo "*** This target requires an assembler supporting \".machine\"" >&2
2715           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
2716           test x$build = x$target && exit 1
2717         fi
2718         conftest_s='    .text
2719         mfcr r3,128';;
2720       *) conftest_s='   .machine power4
2721         .text
2722         mfcr 3,128';;
2723     esac
2724
2725     gcc_GAS_CHECK_FEATURE([mfcr field support],
2726       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2727       [$conftest_s],,
2728       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2729           [Define if your assembler supports mfcr field.])])
2730     ;;
2731
2732   mips*-*-*)
2733     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2734       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2735 [       lw $4,%gp_rel(foo)($4)],,
2736       [if test x$target_cpu_default = x
2737        then target_cpu_default=MASK_EXPLICIT_RELOCS
2738        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2739        fi])
2740
2741     if test x$gas_flag = xyes \
2742        || test x"$host" != x"$build" \
2743        || test ! -x "$gcc_cv_as" \
2744        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
2745       :
2746     else
2747       echo "*** This configuration requires the GNU assembler" >&2
2748       exit 1
2749     fi
2750     ;;
2751 esac
2752 # ??? Not all targets support dwarf2 debug_line, even within a version
2753 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2754 # info to the output file.  So, as supported targets are added to gas 2.11,
2755 # add some instruction here to (also) show we expect this might work.
2756 # ??? Once 2.11 is released, probably need to add first known working
2757 # version to the per-target configury.
2758 case "$target" in
2759   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2760   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2761   | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2762     insn="nop"
2763     ;;
2764   ia64*-*-* | s390*-*-*)
2765     insn="nop 0"
2766     ;;
2767   mmix-*-*)
2768     insn="swym 0"
2769     ;;
2770 esac
2771 if test x"$insn" != x; then
2772  conftest_s="\
2773         .file 1 \"conftest.s\"
2774         .loc 1 3 0
2775         $insn"
2776  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2777   gcc_cv_as_dwarf2_debug_line,
2778   [elf,2,11,0],, [$conftest_s],
2779   [# ??? This fails with non-gnu grep.  Maybe use objdump?
2780    if grep debug_line conftest.o > /dev/null 2>&1; then
2781      gcc_cv_as_dwarf2_debug_line=yes
2782    fi])
2783
2784 # The .debug_line file table must be in the exact order that
2785 # we specified the files, since these indices are also used
2786 # by DW_AT_decl_file.  Approximate this test by testing if
2787 # the assembler bitches if the same index is assigned twice.
2788  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2789   gcc_cv_as_dwarf2_file_buggy,,,
2790 [       .file 1 "foo.s"
2791         .file 1 "bar.s"])
2792
2793  if test $gcc_cv_as_dwarf2_debug_line = yes \
2794  && test $gcc_cv_as_dwarf2_file_buggy = no; then
2795         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2796   [Define if your assembler supports dwarf2 .file/.loc directives,
2797    and preserves file table indices exactly as given.])
2798  fi
2799
2800  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2801   gcc_cv_as_gdwarf2_flag,
2802   [elf,2,11,0], [--gdwarf2], [$insn],,
2803   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2804 [Define if your assembler supports the --gdwarf2 option.])])
2805
2806  gcc_GAS_CHECK_FEATURE([--gstabs option],
2807   gcc_cv_as_gstabs_flag,
2808   [elf,2,11,0], [--gstabs], [$insn],
2809   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2810    # and warns about it, but still exits successfully.  So check for
2811    # this.
2812    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2813    then :
2814    else gcc_cv_as_gstabs_flag=yes
2815    fi],
2816   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2817 [Define if your assembler supports the --gstabs option.])])
2818 fi
2819
2820 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2821 gcc_cv_ld_ro_rw_mix=unknown
2822 if test $in_tree_ld = yes ; then
2823   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \
2824      && test $in_tree_ld_is_elf = yes; then
2825     gcc_cv_ld_ro_rw_mix=read-write
2826   fi
2827 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2828   echo '.section myfoosect, "a"' > conftest1.s
2829   echo '.section myfoosect, "aw"' > conftest2.s
2830   echo '.byte 1' >> conftest2.s
2831   echo '.section myfoosect, "a"' > conftest3.s
2832   echo '.byte 0' >> conftest3.s
2833   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2834      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2835      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2836      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2837         conftest2.o conftest3.o > /dev/null 2>&1; then
2838     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2839                          | sed -e '/myfoosect/!d' -e N`
2840     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2841       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2842         gcc_cv_ld_ro_rw_mix=read-only
2843       else
2844         gcc_cv_ld_ro_rw_mix=read-write
2845       fi
2846     fi
2847   fi
2848 changequote(,)dnl
2849   rm -f conftest.* conftest[123].*
2850 changequote([,])dnl
2851 fi
2852 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2853         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2854   [Define if your linker links a mix of read-only
2855    and read-write sections into a read-write section.])
2856 fi
2857 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2858
2859 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2860 gcc_cv_ld_eh_frame_hdr=no
2861 if test $in_tree_ld = yes ; then
2862   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 \
2863      && test $in_tree_ld_is_elf = yes; then
2864     gcc_cv_ld_eh_frame_hdr=yes
2865   fi
2866 elif test x$gcc_cv_ld != x; then
2867         # Check if linker supports --eh-frame-hdr option
2868         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2869                 gcc_cv_ld_eh_frame_hdr=yes
2870         fi
2871 fi
2872 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2873         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2874 [Define if your linker supports --eh-frame-hdr option.])
2875 fi
2876 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2877
2878 AC_MSG_CHECKING(linker position independent executable support)
2879 gcc_cv_ld_pie=no
2880 if test $in_tree_ld = yes ; then
2881   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2 \
2882      && test $in_tree_ld_is_elf = yes; then
2883     gcc_cv_ld_pie=yes
2884   fi
2885 elif test x$gcc_cv_ld != x; then
2886         # Check if linker supports -pie option
2887         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2888                 gcc_cv_ld_pie=yes
2889         fi
2890 fi
2891 if test x"$gcc_cv_ld_pie" = xyes; then
2892         AC_DEFINE(HAVE_LD_PIE, 1,
2893 [Define if your linker supports -pie option.])
2894 fi
2895 AC_MSG_RESULT($gcc_cv_ld_pie)
2896
2897 # --------
2898 # UNSORTED
2899 # --------
2900
2901 AC_CACHE_CHECK(linker --as-needed support,
2902 gcc_cv_ld_as_needed,
2903 [gcc_cv_ld_as_needed=no
2904 if test $in_tree_ld = yes ; then
2905   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
2906      && test $in_tree_ld_is_elf = yes; then
2907     gcc_cv_ld_as_needed=yes
2908   fi
2909 elif test x$gcc_cv_ld != x; then
2910         # Check if linker supports --as-needed and --no-as-needed options
2911         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
2912                 gcc_cv_ld_as_needed=yes
2913         fi
2914 fi
2915 ])
2916 if test x"$gcc_cv_ld_as_needed" = xyes; then
2917         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
2918 [Define if your linker supports --as-needed and --no-as-needed options.])
2919 fi
2920
2921 case "$target" in
2922   powerpc64*-*-linux*)
2923     AC_CACHE_CHECK(linker support for omitting dot symbols,
2924     gcc_cv_ld_no_dot_syms,
2925     [gcc_cv_ld_no_dot_syms=no
2926     if test $in_tree_ld = yes ; then
2927       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2; then
2928         gcc_cv_ld_no_dot_syms=yes
2929       fi
2930     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
2931       cat > conftest1.s <<EOF
2932         .text
2933         bl .foo
2934 EOF
2935       cat > conftest2.s <<EOF
2936         .section ".opd","aw"
2937         .align 3
2938         .globl foo
2939         .type foo,@function
2940 foo:
2941         .quad .LEfoo,.TOC.@tocbase,0
2942         .text
2943 .LEfoo:
2944         blr
2945         .size foo,.-.LEfoo
2946 EOF
2947       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
2948          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
2949          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
2950         gcc_cv_ld_no_dot_syms=yes
2951       fi
2952       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
2953     fi
2954     ])
2955     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
2956       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
2957     [Define if your PowerPC64 linker only needs function descriptor syms.])
2958     fi
2959     ;;
2960 esac
2961
2962 if test x$with_sysroot = x && test x$host = x$target \
2963    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2964   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2965 [Define to PREFIX/include if cpp should also search that directory.])
2966 fi
2967
2968 # Find out what GC implementation we want, or may, use.
2969 AC_ARG_WITH(gc,
2970 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
2971                           with the compiler],
2972 [case "$withval" in
2973   page | zone)
2974     GGC=ggc-$withval
2975     ;;
2976   *)
2977     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2978     ;;
2979 esac],
2980 [GGC=ggc-page])
2981 AC_SUBST(GGC)
2982 echo "Using $GGC for garbage collection."
2983
2984 # Use the system's zlib library.
2985 zlibdir=-L../zlib
2986 zlibinc="-I\$(srcdir)/../zlib"
2987 AC_ARG_WITH(system-zlib,
2988 [  --with-system-zlib      use installed libz],
2989 zlibdir=
2990 zlibinc=
2991 )
2992 AC_SUBST(zlibdir)
2993 AC_SUBST(zlibinc)
2994
2995 dnl Very limited version of automake's enable-maintainer-mode
2996
2997 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2998   dnl maintainer-mode is disabled by default
2999   AC_ARG_ENABLE(maintainer-mode,
3000 [  --enable-maintainer-mode
3001                           enable make rules and dependencies not useful
3002                           (and sometimes confusing) to the casual installer],
3003       maintainer_mode=$enableval,
3004       maintainer_mode=no)
3005
3006 AC_MSG_RESULT($maintainer_mode)
3007
3008 if test "$maintainer_mode" = "yes"; then
3009   MAINT=''
3010 else
3011   MAINT='#'
3012 fi
3013 AC_SUBST(MAINT)dnl
3014
3015 # --------------
3016 # Language hooks
3017 # --------------
3018
3019 # Make empty files to contain the specs and options for each language.
3020 # Then add #include lines to for a compiler that has specs and/or options.
3021
3022 lang_opt_files=
3023 lang_specs_files=
3024 lang_tree_files=
3025 for subdir in . $subdirs
3026 do
3027         if test -f $srcdir/$subdir/lang.opt; then
3028             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
3029         fi
3030         if test -f $srcdir/$subdir/lang-specs.h; then
3031             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
3032         fi
3033         if test -f $srcdir/$subdir/$subdir-tree.def; then
3034             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
3035         fi
3036 done
3037
3038 # These (without "all_") are set in each config-lang.in.
3039 # `language' must be a single word so is spelled singularly.
3040 all_languages=
3041 all_boot_languages=
3042 all_compilers=
3043 all_stagestuff=
3044 all_outputs='Makefile gccbug mklibgcc libada-mk'
3045 # List of language makefile fragments.
3046 all_lang_makefrags=
3047 # List of language subdirectory makefiles.  Deprecated.
3048 all_lang_makefiles=
3049 # Files for gengtype
3050 all_gtfiles="$target_gtfiles"
3051 # Files for gengtype with language
3052 all_gtfiles_files_langs=
3053 all_gtfiles_files_files=
3054
3055 # Add the language fragments.
3056 # Languages are added via two mechanisms.  Some information must be
3057 # recorded in makefile variables, these are defined in config-lang.in.
3058 # We accumulate them and plug them into the main Makefile.
3059 # The other mechanism is a set of hooks for each of the main targets
3060 # like `clean', `install', etc.
3061
3062 language_hooks="Make-hooks"
3063
3064 for s in $subdirs
3065 do
3066                 language=
3067                 boot_language=
3068                 compilers=
3069                 stagestuff=
3070                 outputs=
3071                 gtfiles=
3072                 . ${srcdir}/$s/config-lang.in
3073                 if test "x$language" = x
3074                 then
3075                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
3076                         exit 1
3077                 fi
3078                 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
3079                 if test -f ${srcdir}/$s/Makefile.in
3080                 then all_lang_makefiles="$s/Makefile"
3081                 fi
3082                 all_languages="$all_languages $language"
3083                 if test "x$boot_language" = xyes
3084                 then
3085                         all_boot_languages="$all_boot_languages $language"
3086                 fi
3087                 all_compilers="$all_compilers $compilers"
3088                 all_stagestuff="$all_stagestuff $stagestuff"
3089                 all_outputs="$all_outputs $outputs"
3090                 all_gtfiles="$all_gtfiles $gtfiles"
3091                 for f in $gtfiles
3092                 do
3093                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3094                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3095                 done
3096 done
3097
3098 # Pick up gtfiles for c
3099 gtfiles=
3100 s="c"
3101 . ${srcdir}/c-config-lang.in
3102 all_gtfiles="$all_gtfiles $gtfiles"
3103 for f in $gtfiles
3104 do
3105         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3106         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3107 done
3108
3109 check_languages=
3110 for language in $all_languages
3111 do
3112                 check_languages="$check_languages check-$language"
3113 done
3114
3115 # We link each language in with a set of hooks, reached indirectly via
3116 # lang.${target}.
3117
3118 rm -f Make-hooks
3119 touch Make-hooks
3120 target_list="all.build all.cross start.encap rest.encap tags \
3121         install-normal install-common install-man \
3122         uninstall info man srcextra srcman srcinfo \
3123         mostlyclean clean distclean maintainer-clean \
3124         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
3125 for t in $target_list
3126 do
3127         x=
3128         for lang in $all_languages
3129         do
3130                         x="$x $lang.$t"
3131         done
3132         echo "lang.$t: $x" >> Make-hooks
3133 done
3134
3135 # --------
3136 # UNSORTED
3137 # --------
3138
3139 # Create .gdbinit.
3140
3141 echo "dir ." > .gdbinit
3142 echo "dir ${srcdir}" >> .gdbinit
3143 if test x$gdb_needs_out_file_path = xyes
3144 then
3145         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3146 fi
3147 if test "x$subdirs" != x; then
3148         for s in $subdirs
3149         do
3150                 echo "dir ${srcdir}/$s" >> .gdbinit
3151         done
3152 fi
3153 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3154
3155 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3156 # absolute path for gcc_tooldir based on inserting the number of up-directory
3157 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3158 # $(libsubdir)/@(unlibsubdir) based path.
3159 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3160 # make and thus we'd get different behavior depending on where we built the
3161 # sources.
3162 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3163     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
3164 else
3165 changequote(<<, >>)dnl
3166 # An explanation of the sed strings:
3167 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
3168 #  -e 's|/$||'            match a trailing forward slash and eliminates it
3169 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
3170 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
3171 #
3172 # (*) Note this pattern overwrites the first character of the string
3173 # with a forward slash if one is not already present.  This is not a
3174 # problem because the exact names of the sub-directories concerned is
3175 # unimportant, just the number of them matters.
3176 #
3177 # The practical upshot of these patterns is like this:
3178 #
3179 #  prefix     exec_prefix        result
3180 #  ------     -----------        ------
3181 #   /foo        /foo/bar          ../
3182 #   /foo/       /foo/bar          ../
3183 #   /foo        /foo/bar/         ../
3184 #   /foo/       /foo/bar/         ../
3185 #   /foo        /foo/bar/ugg      ../../
3186 #
3187     dollar='$$'
3188     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
3189 changequote([, ])dnl
3190 fi
3191 AC_SUBST(gcc_tooldir)
3192 AC_SUBST(dollar)
3193
3194 # Find a directory in which to install a shared libgcc.
3195
3196 AC_ARG_ENABLE(version-specific-runtime-libs,
3197 [  --enable-version-specific-runtime-libs
3198                           specify that runtime libraries should be
3199                           installed in a compiler-specific directory])
3200
3201 AC_ARG_WITH(slibdir,
3202 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3203 slibdir="$with_slibdir",
3204 if test "${enable_version_specific_runtime_libs+set}" = set; then
3205   slibdir='$(libsubdir)'
3206 elif test "$host" != "$target"; then
3207   slibdir='$(build_tooldir)/lib'
3208 else
3209   slibdir='$(libdir)'
3210 fi)
3211 AC_SUBST(slibdir)
3212
3213 objdir=`${PWDCMD-pwd}`
3214 AC_SUBST(objdir)
3215
3216 # Substitute configuration variables
3217 AC_SUBST(subdirs)
3218 AC_SUBST(srcdir)
3219 AC_SUBST(all_boot_languages)
3220 AC_SUBST(all_compilers)
3221 AC_SUBST(all_gtfiles)
3222 AC_SUBST(all_gtfiles_files_langs)
3223 AC_SUBST(all_gtfiles_files_files)
3224 AC_SUBST(all_lang_makefrags)
3225 AC_SUBST(all_lang_makefiles)
3226 AC_SUBST(all_languages)
3227 AC_SUBST(all_stagestuff)
3228 AC_SUBST(build_exeext)
3229 AC_SUBST(build_install_headers_dir)
3230 AC_SUBST(build_xm_file_list)
3231 AC_SUBST(build_xm_include_list)
3232 AC_SUBST(build_xm_defines)
3233 AC_SUBST(check_languages)
3234 AC_SUBST(cc_set_by_configure)
3235 AC_SUBST(quoted_cc_set_by_configure)
3236 AC_SUBST(cpp_install_dir)
3237 AC_SUBST(xmake_file)
3238 AC_SUBST(tmake_file)
3239 AC_SUBST(extra_gcc_objs)
3240 AC_SUBST(extra_headers_list)
3241 AC_SUBST(extra_objs)
3242 AC_SUBST(extra_parts)
3243 AC_SUBST(extra_passes)
3244 AC_SUBST(extra_programs)
3245 AC_SUBST(float_h_file)
3246 AC_SUBST(gcc_config_arguments)
3247 AC_SUBST(gcc_gxx_include_dir)
3248 AC_SUBST(libstdcxx_incdir)
3249 AC_SUBST(gcc_version)
3250 AC_SUBST(gcc_version_full)
3251 AC_SUBST(gcc_version_trigger)
3252 AC_SUBST(host_exeext)
3253 AC_SUBST(host_xm_file_list)
3254 AC_SUBST(host_xm_include_list)
3255 AC_SUBST(host_xm_defines)
3256 AC_SUBST(out_host_hook_obj)
3257 AC_SUBST(install)
3258 AC_SUBST(lang_opt_files)
3259 AC_SUBST(lang_specs_files)
3260 AC_SUBST(lang_tree_files)
3261 AC_SUBST(local_prefix)
3262 AC_SUBST(md_file)
3263 AC_SUBST(objc_boehm_gc)
3264 AC_SUBST(out_file)
3265 AC_SUBST(out_object_file)
3266 AC_SUBST(stage_prefix_set_by_configure)
3267 AC_SUBST(quoted_stage_prefix_set_by_configure)
3268 AC_SUBST(thread_file)
3269 AC_SUBST(tm_file_list)
3270 AC_SUBST(tm_include_list)
3271 AC_SUBST(tm_defines)
3272 AC_SUBST(tm_p_file_list)
3273 AC_SUBST(tm_p_include_list)
3274 AC_SUBST(xm_file_list)
3275 AC_SUBST(xm_include_list)
3276 AC_SUBST(xm_defines)
3277 AC_SUBST(c_target_objs)
3278 AC_SUBST(cxx_target_objs)
3279 AC_SUBST(target_cpu_default)
3280
3281 AC_SUBST_FILE(language_hooks)
3282
3283 TL_AC_GNU_MAKE_GCC_LIB_PATH
3284
3285 # Echo link setup.
3286 if test x${build} = x${host} ; then
3287   if test x${host} = x${target} ; then
3288     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3289   else
3290     echo "Links are now set up to build a cross-compiler" 1>&2
3291     echo " from ${host} to ${target}." 1>&2
3292   fi
3293 else
3294   if test x${host} = x${target} ; then
3295     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3296     echo " for ${target}." 1>&2
3297   else
3298     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3299     echo " from ${host} to ${target}." 1>&2
3300   fi
3301 fi
3302
3303 AC_ARG_VAR(GMPLIBS,[How to link GMP])
3304 AC_ARG_VAR(GMPINC,[How to find GMP include files])
3305
3306 # Configure the subdirectories
3307 # AC_CONFIG_SUBDIRS($subdirs)
3308
3309 # Create the Makefile
3310 # and configure language subdirectories
3311 AC_CONFIG_FILES($all_outputs)
3312
3313 AC_CONFIG_COMMANDS([default],
3314 [
3315 case ${CONFIG_HEADERS} in
3316   *auto-host.h:config.in*)
3317   echo > cstamp-h ;;
3318 esac
3319 # Make sure all the subdirs exist.
3320 for d in $subdirs doc build
3321 do
3322     test -d $d || mkdir $d
3323 done
3324 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3325 # bootstrapping and the installation procedure can still use
3326 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3327 # FLAGS_TO_PASS has been modified to solve the problem there.
3328 # This is virtually a duplicate of what happens in configure.lang; we do
3329 # an extra check to make sure this only happens if ln -s can be used.
3330 case "$LN_S" in
3331   *-s*)
3332     for d in ${subdirs} ; do
3333         STARTDIR=`${PWDCMD-pwd}`
3334         cd $d
3335         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3336         do
3337                 rm -f $t
3338                 $LN_S ../$t $t 2>/dev/null
3339         done
3340         cd $STARTDIR
3341     done
3342   ;;
3343 esac
3344 ],
3345 [subdirs='$subdirs'])
3346 AC_OUTPUT