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